{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 一、导入必要的模块"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 一、导入相关模块  \n",
    "import torch  \n",
    "import torch.nn as nn  \n",
    "import torch.optim as optim  \n",
    "import numpy as np  \n",
    "import pandas as pd  \n",
    "from torch.utils.data import Dataset, DataLoader  \n",
    "import re  \n",
    "import tkinter as tk  \n",
    "from tkinter import messagebox  \n",
    "from PIL import Image, ImageTk  \n",
    "import matplotlib.pyplot as plt  \n",
    "from sklearn.metrics import precision_score, recall_score, accuracy_score \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 二、数据处理和构建词汇表"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "加载数据: data/input/training_set.txt，样本数量: 19998\n",
      "加载数据: data/input/validation_set.txt，样本数量: 5998\n",
      "\n",
      "清洗后的训练文本数量: 19998\n",
      "清洗后的验证文本数量: 5998\n",
      "词汇表大小: 5000\n",
      "\n",
      "标签分布:\n",
      "训练集: {1: 9999, 0: 9999}\n",
      "验证集: {1: 2999, 0: 2999}\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "from collections import Counter\n",
    "import pandas as pd\n",
    "\n",
    "def load_data(file_path):  \n",
    "    texts, labels = [], []  \n",
    "    # 从指定路径加载数据集  \n",
    "    with open(file_path, 'r', encoding='utf-8') as f:  \n",
    "        for line in f:  \n",
    "            label, text = line.strip().split('\\t')  # 每行数据由标签与文本组成  \n",
    "            texts.append(text)  \n",
    "            labels.append(int(label))  # 将标签转换为整数  \n",
    "    print(f\"加载数据: {file_path}，样本数量: {len(texts)}\")  # 打印样本数量\n",
    "    return texts, labels  \n",
    "\n",
    "def clean_text(text):  \n",
    "    # 去除文本中的非中文字符  \n",
    "    text = re.sub(r'[^\\u4e00-\\u9fa5]', '', text)  \n",
    "    return text.strip()  # 返回去掉前后空格后的文本  \n",
    "\n",
    "def build_vocab(texts, max_vocab_size=5000):  \n",
    "    word_counts = Counter()  # 统计每个词的出现次数  \n",
    "    for text in texts:  \n",
    "        word_counts.update(text)  # 更新词频统计  \n",
    "    # 构建词汇表，并为每个词分配唯一的索引  \n",
    "    vocab = {word: i + 1 for i, (word, _) in enumerate(word_counts.most_common(max_vocab_size))}  \n",
    "    return vocab  \n",
    "\n",
    "def text_to_sequence(text, vocab, max_len=100):  \n",
    "    # 将文本转换为词汇表索引序列  \n",
    "    tokens = list(text)  # 将文本拆分为单个字符  \n",
    "    sequence = [vocab.get(token, 0) for token in tokens]  # 将字符转换为索引，未知字符用0表示  \n",
    "    sequence = sequence[:max_len] + [0] * (max_len - len(sequence))  # 序列填充到最大长度  \n",
    "    return sequence  \n",
    "\n",
    "# 加载数据  \n",
    "train_texts, train_labels = load_data('data/input/training_set.txt')  # 加载训练集  \n",
    "val_texts, val_labels = load_data('data/input/validation_set.txt')  # 加载验证集  \n",
    "train_texts = [clean_text(text) for text in train_texts]  # 清洗训练文本  \n",
    "val_texts = [clean_text(text) for text in val_texts]  # 清洗验证文本  \n",
    "\n",
    "# 打印清洗后的文本数量\n",
    "print(f\"\\n清洗后的训练文本数量: {len(train_texts)}\")\n",
    "print(f\"清洗后的验证文本数量: {len(val_texts)}\")\n",
    "\n",
    "# 构建词汇表  \n",
    "vocab = build_vocab(train_texts)  \n",
    "print(f\"词汇表大小: {len(vocab)}\")  # 打印词汇表大小\n",
    "\n",
    "# 将文本转换为索引序列  \n",
    "train_sequences = [text_to_sequence(text, vocab) for text in train_texts]  \n",
    "val_sequences = [text_to_sequence(text, vocab) for text in val_texts]  \n",
    "\n",
    "# 标签分布检查\n",
    "train_label_dist = pd.Series(train_labels).value_counts().to_dict()\n",
    "val_label_dist = pd.Series(val_labels).value_counts().to_dict()\n",
    "\n",
    "print(\"\\n标签分布:\")\n",
    "print(f\"训练集: {train_label_dist}\")  # 打印训练集标签分布\n",
    "print(f\"验证集: {val_label_dist}\")    # 打印验证集标签分布"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 三、创建深度神经网络模型——LSTM和RNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RNN模型构建成功\n",
      "LSTM模型构建成功\n"
     ]
    }
   ],
   "source": [
    "\n",
    "class RNNClassifier(nn.Module):  \n",
    "    def __init__(self, vocab_size, embedding_dim, hidden_dim, num_layers, dropout):  \n",
    "        super(RNNClassifier, self).__init__()  \n",
    "        self.embedding = nn.Embedding(vocab_size, embedding_dim)  # 嵌入层  \n",
    "        self.rnn = nn.RNN(embedding_dim, hidden_dim, num_layers=num_layers, dropout=dropout, batch_first=True, bidirectional=True)  # 双向RNN层  \n",
    "        self.fc = nn.Linear(hidden_dim * 2, 2)  # 全连接层，乘以2因为是双向  \n",
    "        print(\"RNN模型构建成功\")  # 打印RNN模型构建成功的消息\n",
    "\n",
    "    def forward(self, x):  \n",
    "        x = self.embedding(x)  # 得到嵌入表示  \n",
    "        x, _ = self.rnn(x)  # RNN输出  \n",
    "        x = x[:, -1, :]  # 取最后一个时刻的输出  \n",
    "        return self.fc(x)  # 返回分类结果  \n",
    "\n",
    "class ImprovedLSTMClassifier(nn.Module):  \n",
    "    def __init__(self, vocab_size, embedding_dim, hidden_dim, num_layers, dropout):  \n",
    "        super(ImprovedLSTMClassifier, self).__init__()  \n",
    "        self.embedding = nn.Embedding(vocab_size, embedding_dim)  # 嵌入层  \n",
    "        self.lstm = nn.LSTM(embedding_dim, hidden_dim, num_layers=num_layers, dropout=dropout, batch_first=True, bidirectional=True)  # 双向LSTM层  \n",
    "        self.fc = nn.Linear(hidden_dim * 2, 2)  # 全连接层，乘以2因为是双向  \n",
    "        print(\"LSTM模型构建成功\")  # 打印LSTM模型构建成功的消息\n",
    "\n",
    "    def forward(self, x):  \n",
    "        x = self.embedding(x)  # 得到嵌入表示  \n",
    "        x, _ = self.lstm(x)  # LSTM输出  \n",
    "        x = x[:, -1, :]  # 取最后一个时刻的输出  \n",
    "        return self.fc(x)  # 返回分类结果  \n",
    "\n",
    "# 示例：构建模型实例\n",
    "vocab_size = 5000\n",
    "embedding_dim = 128\n",
    "hidden_dim = 128  # 增加隐藏层单元数\n",
    "num_layers = 3    # 增加层数\n",
    "dropout = 0.5\n",
    "\n",
    "# 创建模型实例\n",
    "rnn_model = RNNClassifier(vocab_size, embedding_dim, hidden_dim, num_layers, dropout)\n",
    "lstm_model = ImprovedLSTMClassifier(vocab_size, embedding_dim, hidden_dim, num_layers, dropout)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 四、配置神经网络模型\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RNN模型构建成功\n",
      "LSTM模型构建成功\n",
      "\n",
      "RNN模型信息:\n",
      "RNNClassifier(\n",
      "  (embedding): Embedding(5001, 200)\n",
      "  (rnn): RNN(200, 256, num_layers=2, batch_first=True, dropout=0.5, bidirectional=True)\n",
      "  (fc): Linear(in_features=512, out_features=2, bias=True)\n",
      ")\n",
      "可训练参数数量: 1629962\n",
      "\n",
      "LSTM模型信息:\n",
      "ImprovedLSTMClassifier(\n",
      "  (embedding): Embedding(5001, 200)\n",
      "  (lstm): LSTM(200, 256, num_layers=2, batch_first=True, dropout=0.5, bidirectional=True)\n",
      "  (fc): Linear(in_features=512, out_features=2, bias=True)\n",
      ")\n",
      "可训练参数数量: 3516170\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "\n",
    "# 配置参数\n",
    "embedding_dim = 200  # 嵌入层维度  \n",
    "hidden_dim = 256  # 隐藏层维度  \n",
    "num_layers = 2  # RNN或LSTM层数  \n",
    "dropout = 0.5  # Dropout比例  \n",
    "vocab_size = len(vocab) + 1  # 词汇表大小（加1用于UNK）  \n",
    "\n",
    "# 定义损失函数和设备\n",
    "criterion = nn.CrossEntropyLoss()  # 损失函数  \n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")  # 确定设备  \n",
    "\n",
    "# 将数据转换为Tensor  \n",
    "train_sequences = torch.LongTensor(train_sequences)  # 训练数据序列  \n",
    "val_sequences = torch.LongTensor(val_sequences)  # 验证数据序列  \n",
    "train_labels = torch.LongTensor(train_labels)  # 训练数据标签  \n",
    "val_labels = torch.LongTensor(val_labels)  # 验证数据标签  \n",
    "\n",
    "# 自定义数据集  \n",
    "class TextDataset(Dataset):  \n",
    "    def __init__(self, sequences, labels):  \n",
    "        self.sequences = sequences  \n",
    "        self.labels = labels  \n",
    "\n",
    "    def __len__(self):  \n",
    "        return len(self.labels)  # 返回数据集大小  \n",
    "\n",
    "    def __getitem__(self, idx):  \n",
    "        return self.sequences[idx], self.labels[idx]  # 返回指定索引的数据  \n",
    "\n",
    "# 创建数据集和数据加载器  \n",
    "train_dataset = TextDataset(train_sequences, train_labels)  \n",
    "val_dataset = TextDataset(val_sequences, val_labels)  \n",
    "\n",
    "train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)  # 训练数据加载器  \n",
    "val_loader = DataLoader(val_dataset, batch_size=64, shuffle=False)  # 验证数据加载器  \n",
    "\n",
    "# 创建模型实例\n",
    "rnn_model = RNNClassifier(vocab_size, embedding_dim, hidden_dim, num_layers, dropout).to(device)\n",
    "lstm_model = ImprovedLSTMClassifier(vocab_size, embedding_dim, hidden_dim, num_layers, dropout).to(device)\n",
    "\n",
    "# 打印模型参数数量和结构信息\n",
    "def print_model_info(model, model_name):\n",
    "    print(f\"\\n{model_name}模型信息:\")\n",
    "    print(model)  # 打印模型结构\n",
    "    num_params = sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
    "    print(f\"可训练参数数量: {num_params}\")\n",
    "\n",
    "# 打印RNN和LSTM模型信息\n",
    "print_model_info(rnn_model, \"RNN\")\n",
    "print_model_info(lstm_model, \"LSTM\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 五、训练评估模型LSTM与RNN，选择出最佳模型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "训练并且评估两个模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RNN模型构建成功\n",
      "\n",
      "开始训练RNN模型...\n",
      "Epoch [1/10], Train Loss: 0.7161, Val Loss: 0.6915, Val Acc: 0.5193, Val Precision: 0.5667, Val Recall: 0.5193\n",
      "Epoch [2/10], Train Loss: 0.6983, Val Loss: 0.6980, Val Acc: 0.4992, Val Precision: 0.4957, Val Recall: 0.4992\n",
      "Epoch [3/10], Train Loss: 0.6937, Val Loss: 0.6998, Val Acc: 0.4988, Val Precision: 0.4988, Val Recall: 0.4988\n",
      "Epoch [4/10], Train Loss: 0.6937, Val Loss: 0.7126, Val Acc: 0.5080, Val Precision: 0.5217, Val Recall: 0.5080\n",
      "Epoch [5/10], Train Loss: 0.6880, Val Loss: 0.7097, Val Acc: 0.5153, Val Precision: 0.5155, Val Recall: 0.5153\n",
      "Epoch [6/10], Train Loss: 0.6796, Val Loss: 0.7282, Val Acc: 0.5130, Val Precision: 0.5323, Val Recall: 0.5130\n",
      "Epoch [7/10], Train Loss: 0.6729, Val Loss: 0.7189, Val Acc: 0.5148, Val Precision: 0.5201, Val Recall: 0.5148\n",
      "Epoch [8/10], Train Loss: 0.6639, Val Loss: 0.7278, Val Acc: 0.5093, Val Precision: 0.5095, Val Recall: 0.5093\n",
      "Epoch [9/10], Train Loss: 0.6500, Val Loss: 0.7554, Val Acc: 0.5118, Val Precision: 0.5296, Val Recall: 0.5118\n",
      "Epoch [10/10], Train Loss: 0.6457, Val Loss: 0.7412, Val Acc: 0.5193, Val Precision: 0.5198, Val Recall: 0.5193\n",
      "LSTM模型构建成功\n",
      "\n",
      "开始训练LSTM模型...\n"
     ]
    }
   ],
   "source": [
    "# 训练和评估函数\n",
    "def train_and_evaluate(model, train_loader, val_loader, criterion, optimizer, epochs):\n",
    "    model.to(device)  # 将模型移动到指定设备\n",
    "    best_val_acc = 0  # 初始化最佳验证准确率\n",
    "\n",
    "    # 初始化记录指标的列表  \n",
    "    train_losses, val_losses, val_accuracies, val_precisions, val_recalls = [], [], [], [], []  \n",
    "\n",
    "    for epoch in range(epochs):  \n",
    "        model.train()  # 设置模型为训练模式  \n",
    "        epoch_train_loss = 0  # 本轮训练损失初始化  \n",
    "        \n",
    "        for sequences, labels in train_loader:  \n",
    "            sequences, labels = sequences.to(device), labels.to(device)  # 将数据移动到设备  \n",
    "            optimizer.zero_grad()  # 清空梯度  \n",
    "            outputs = model(sequences)  # 模型前向传播  \n",
    "            loss = criterion(outputs, labels)  # 计算损失  \n",
    "            loss.backward()  # 反向传播  \n",
    "            optimizer.step()  # 更新权重  \n",
    "            epoch_train_loss += loss.item()  # 累计训练损失  \n",
    "\n",
    "        avg_train_loss = epoch_train_loss / len(train_loader)  # 计算平均训练损失  \n",
    "        train_losses.append(avg_train_loss)  # 记录训练损失  \n",
    "\n",
    "        # 在验证集上评估  \n",
    "        model.eval()  # 设置模型为评估模式  \n",
    "        val_total_loss = 0  # 初始化验证损失  \n",
    "        all_preds = []  # 初始化预测列表  \n",
    "        all_labels = []  # 初始化标签列表  \n",
    "        \n",
    "        with torch.no_grad():  # 禁用梯度计算  \n",
    "            for sequences, labels in val_loader:  \n",
    "                sequences, labels = sequences.to(device), labels.to(device)  # 移动数据到设备  \n",
    "                outputs = model(sequences)  # 模型前向传播  \n",
    "                loss = criterion(outputs, labels)  # 计算损失  \n",
    "                val_total_loss += loss.item()  # 累计验证损失  \n",
    "                _, predicted = outputs.max(1)  # 获取预测结果  \n",
    "                all_preds.extend(predicted.cpu().numpy())  # 转移到CPU并添加到预测列表  \n",
    "                all_labels.extend(labels.cpu().numpy())  # 转移到CPU并添加到标签列表  \n",
    "\n",
    "        val_loss = val_total_loss / len(val_loader)  # 计算验证损失  \n",
    "        val_accuracy = accuracy_score(all_labels, all_preds)  # 计算验证准确率  \n",
    "        val_precision = precision_score(all_labels, all_preds, average='weighted')  # 计算验证精确率  \n",
    "        val_recall = recall_score(all_labels, all_preds, average='weighted')  # 计算验证召回率  \n",
    "\n",
    "        # 记录验证集的评估指标  \n",
    "        val_losses.append(val_loss)  \n",
    "        val_accuracies.append(val_accuracy)  \n",
    "        val_precisions.append(val_precision)  \n",
    "        val_recalls.append(val_recall)  \n",
    "\n",
    "        # 输出当前epoch的结果  \n",
    "        print(f\"Epoch [{epoch+1}/{epochs}], Train Loss: {avg_train_loss:.4f}, Val Loss: {val_loss:.4f}, \"\n",
    "              f\"Val Acc: {val_accuracy:.4f}, Val Precision: {val_precision:.4f}, Val Recall: {val_recall:.4f}\")  \n",
    "\n",
    "        # 如果当前验证准确率更高，保存模型  \n",
    "        if val_accuracy > best_val_acc:  \n",
    "            best_val_acc = val_accuracy  \n",
    "            model_name = 'RNN_model.pth' if isinstance(model, RNNClassifier) else 'LSTM_model.pth'\n",
    "            torch.save(model.state_dict(), f'model/{model_name}')  \n",
    "\n",
    "    return train_losses, val_losses, val_accuracies, val_precisions, val_recalls  # 返回所有指标  \n",
    "\n",
    "# 训练RNN模型  \n",
    "rnn_model = RNNClassifier(vocab_size, embedding_dim, hidden_dim, num_layers, dropout).to(device)  # 创建模型  \n",
    "rnn_optimizer = optim.AdamW(rnn_model.parameters(), lr=0.001, weight_decay=0.01)  # 设置优化器  \n",
    "\n",
    "print(\"\\n开始训练RNN模型...\")  \n",
    "rnn_losses, rnn_val_losses, rnn_val_accuracies, rnn_val_precisions, rnn_val_recalls = train_and_evaluate(rnn_model, train_loader, val_loader, criterion, rnn_optimizer, 10)  \n",
    "\n",
    "# 训练LSTM模型  \n",
    "lstm_model = ImprovedLSTMClassifier(vocab_size, embedding_dim, hidden_dim, num_layers, dropout).to(device)  # 创建模型  \n",
    "lstm_optimizer = optim.AdamW(lstm_model.parameters(), lr=0.001, weight_decay=0.01)  # 设置优化器  \n",
    "\n",
    "print(\"\\n开始训练LSTM模型...\")  \n",
    "lstm_losses, lstm_val_losses, lstm_val_accuracies, lstm_val_precisions, lstm_val_recalls = train_and_evaluate(lstm_model, train_loader, val_loader, criterion, lstm_optimizer, 10)\n",
    "\n",
    "# 比较模型准确率并选择最佳模型\n",
    "best_model_name = 'RNN' if max(rnn_val_accuracies) > max(lstm_val_accuracies) else 'LSTM'\n",
    "print(f\"\\n最佳模型是: {best_model_name}，准确率为: {max(rnn_val_accuracies) if best_model_name == 'RNN' else max(lstm_val_accuracies):.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 六、模型数据可视化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAJOCAYAAABm7rQwAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeVxU1f/H8dcwbIL7BogUlrnmUpjkV01MkMosM01TM62sTFPj26ItbpWWlVnpL74ZlvXNJf1aWZqCu5ZLaW6pmLmj4C4GyTLM748rkwgIKsMd4P18PObB5cyZM5/LBb18OOdzLHa73Y6IiIiIiIiIiEgxcjM7ABERERERERERKXuUlBIRERERERERkWKnpJSIiIiIiIiIiBQ7JaVERERERERERKTYKSklIiIiIiIiIiLFTkkpEREREREREREpdkpKiYiIiIiIiIhIsVNSSkREREREREREip2SUiIiIiIiIiIiUuyUlBIRuYywsDDCwsKu6rX9+vUjODi4SOMRERERcaYVK1ZgsVhYsWKFo62w9zT79+/HYrHw+eefF2lMwcHB9OvXr0jHFBHXoKSUiOTy+eefY7FYHA93d3cCAwPp168fCQkJufqHhYVhsVjo3Llzrueyb07effddR1v2zY7FYmHjxo25XtOvXz/Kly+fb3zZYxbmsX///qv7IpRwYWFh3HzzzWaHISIiUmK5+v0QQNOmTbnuuuuw2+359mndujV+fn5kZmZediyz/fzzz4wePZozZ86YHYpD9vfAr7/+anYoIqWWu9kBiIjrGjt2LHXq1OH8+fOsW7eOzz//nDVr1rB9+3a8vb1z9f/hhx/YuHEjISEhhX6P0aNH8/33319RXDVq1ODLL7/M0fbee+9x+PBh3n///Vx9r0VsbOxVv3bq1KlkZWVd0/uLiIiIuVz1fgigd+/eDB8+nNWrV3PHHXfken7//v2sXbuWwYMH4+5+9b/6Fcc9zc8//8yYMWPo168flStXzvFcfHw8bm6aTyFSGikpJSL5uvvuu2nRogUATzzxBNWrV+ftt99m/vz5PPTQQzn6XnfddZw7d44xY8Ywf/78Qo3fvHlzfvjhBzZt2sStt95a6Lh8fX3p06dPjrZZs2Zx+vTpXO0Xs9vtnD9/nnLlyhX6vTw9PQvd91IeHh5X/VoRERFxDa56PwTQq1cvRowYwYwZM/JMSs2cORO73U7v3r2vaNxLmX1P4+XlZer7i4jzKN0sIoXWtm1bAP78889cz1WoUIHnnnuO77//nk2bNhVqvGeffZYqVaowevToogzTITg4mHvvvZfFixfTokULypUrx3/+8x8APvvsM+68805q1qyJl5cXjRo14uOPP841xqU1pbKn2n/99de8+eab1K5dG29vbzp06MCePXtyvPbS+gsXT93/5JNPuPHGG/Hy8uK2227jl19+yfXec+bMoVGjRnh7e3PzzTfzzTffFHmdqv/7v/+jcePGeHl5UatWLQYNGpRr2vwff/zBgw8+iL+/P97e3tSuXZuePXty9uxZR5+4uDjatGlD5cqVKV++PPXr1+fll18usjhFRERchSvdDwUFBXHHHXcwd+5cMjIycj0/Y8YMbrzxRkJDQzlw4ADPPPMM9evXp1y5clSrVo3u3bsXqtRBXvcfZ86coV+/flSqVInKlSvz6KOP5rn0buvWrfTr148bbrgBb29v/P39eeyxxzh58qSjz+jRo3nhhRcAqFOnTq4yDHnVlNq7dy/du3enatWq+Pj4cPvtt7NgwYIcfa7kvu1a/Pbbb9x9991UrFiR8uXL06FDB9atW5ejT0ZGBmPGjOGmm27C29ubatWq0aZNG+Li4hx9EhMT6d+/P7Vr18bLy4uAgADuv//+MluOQsoGzZQSkULL/g+xSpUqeT4/dOhQ3n//fUaPHl2ovw5WrFiR5557jpEjR17VXwcLIz4+nocffpinnnqKAQMGUL9+fQA+/vhjGjduzH333Ye7uzvff/89zzzzDFlZWQwaNKjAcd966y3c3Nx4/vnnOXv2LBMmTKB3796sX7++wNfOmDGDc+fO8dRTT2GxWJgwYQJdu3Zl7969jr9ELliwgB49etCkSRPGjx/P6dOnefzxxwkMDLy2L8hFRo8ezZgxYwgPD2fgwIHEx8fz8ccf88svv/DTTz/h4eFBeno6kZGRpKWl8eyzz+Lv709CQgI//PADZ86coVKlSvz+++/ce++9NG3alLFjx+Ll5cWePXv46aefiixWERERV+Fq90O9e/fmySefZPHixdx7772O9m3btrF9+3ZGjhwJwC+//MLPP/9Mz549qV27Nvv37+fjjz8mLCyMHTt24OPjU+j3tNvt3H///axZs4ann36ahg0b8s033/Doo4/m6hsXF8fevXvp378//v7+/P7773zyySf8/vvvrFu3DovFQteuXdm9ezczZ87k/fffp3r16kD+ZRiSkpL417/+RWpqKkOGDKFatWpMnz6d++67j7lz5/LAAw/k6H8t920F+f3332nbti0VK1bkxRdfxMPDg//85z+EhYWxcuVKQkNDAeO+a/z48TzxxBO0bNmS5ORkfv31VzZt2kRERAQADz74IL///jvPPvsswcHBHDt2jLi4OA4ePKjNc6T0souIXOKzzz6zA/YlS5bYjx8/bj906JB97ty59ho1ati9vLzshw4dytG/Xbt29saNG9vtdrt9zJgxdsC+ceNGu91ut+/bt88O2N955x1H/+XLl9sB+5w5c+xnzpyxV6lSxX7fffc5nn/00Uftvr6+VxRzp06d7Ndff32Otuuvv94O2BctWpSrf2pqaq62yMhI+w033JDr3Nq1a5cr9oYNG9rT0tIc7R988IEdsG/bti3HeVwcU/bXolq1avZTp0452r/77js7YP/+++8dbU2aNLHXrl3bfu7cOUfbihUr7ECu88zLxdckL8eOHbN7enraO3bsaLfZbI72yZMn2wH7tGnT7Ha73f7bb785rlV+3n//fTtgP378eIFxiYiIlBQl5X7o1KlTdi8vL/vDDz+co3348OF2wB4fH2+32/O+91m7dq0dsH/xxRe54lq+fHmOWC6+//j222/tgH3ChAmOtszMTHvbtm3tgP2zzz5ztOf1vjNnzrQD9lWrVjna3nnnHTtg37dvX67+119/vf3RRx91fD5s2DA7YF+9erWj7dy5c/Y6derYg4ODHfc2V3Lflpfs74Fffvkl3z5dunSxe3p62v/8809H25EjR+wVKlSw33HHHY62Zs2a2Tt16pTvOKdPn871PSJSFmj5nojkKzw8nBo1ahAUFES3bt3w9fVl/vz51K5dO9/XDB06lCpVqjBmzJhCvUelSpUYNmwY8+fP57fffiuq0B3q1KlDZGRkrvaL60qdPXuWEydO0K5dO/bu3ZtjWVp++vfvn6PeVPZU/r179xb42h49euT46+qlrz1y5Ajbtm2jb9++OXbdadeuHU2aNClw/MJYsmQJ6enpDBs2LEfh0AEDBlCxYkXH9PdKlSoBsHjxYlJTU/McK7sY6XfffafC7iIiUuq4+v1QlSpVuOeee5g/fz4pKSmAMZNp1qxZtGjRgnr16gE5730yMjI4efIkdevWpXLlyoVeapht4cKFuLu7M3DgQEeb1Wrl2WefzdX34vc9f/48J06c4Pbbbwe44ve9+P1btmxJmzZtHG3ly5fnySefZP/+/ezYsSNH/2u5b7scm81GbGwsXbp04YYbbnC0BwQE0KtXL9asWUNycjJg3C/9/vvv/PHHH3mOVa5cOTw9PVmxYgWnT5++prhEShIlpUQkX1OmTCEuLo65c+dyzz33cOLEiQILTV7NTdXQoUOpXLmyU2pL1alTJ8/2n376ifDwcHx9falcuTI1atRw1EAqTFLquuuuy/F5dpKpMDcRBb32wIEDANStWzfXa/NquxrZ75G9nDGbp6cnN9xwg+P5OnXqEBUVxaeffkr16tWJjIxkypQpOb5GPXr0oHXr1jzxxBP4+fnRs2dPvv76ayWoRESkVCgJ90O9e/cmJSWF7777DjB2stu/f3+OAud///03I0eOJCgoCC8vL6pXr06NGjU4c+ZMoe59LnbgwAECAgJy/PEMct9XAJw6dYqhQ4fi5+dHuXLlqFGjhuP+7Erf9+L3z+u9GjZs6Hj+Ytdy33Y5x48fJzU1Nd9YsrKyOHToEGDs4njmzBnq1atHkyZNeOGFF9i6daujv5eXF2+//TY//vgjfn5+3HHHHUyYMIHExMRrilHE1SkpJSL5atmyJeHh4Tz44IPMnz+fm2++mV69evHXX39d9nXZN1WuMFsqr532/vzzTzp06MCJEyeYOHEiCxYsIC4ujueeew6gUMkUq9WaZ7vdbnfqa83w3nvvsXXrVl5++WX+/vtvhgwZQuPGjTl8+DBgfI1XrVrFkiVLeOSRR9i6dSs9evQgIiICm81mcvQiIiLXpiTcD917771UqlSJGTNmAEb9SqvVSs+ePR19nn32Wd58800eeughvv76a2JjY4mLi6NatWpO/UPSQw89xNSpU3n66aeZN28esbGxLFq0CCjcPVdRcIV7rzvuuIM///yTadOmcfPNN/Ppp59y66238umnnzr6DBs2jN27dzN+/Hi8vb157bXXaNiwoVNWE4i4CiWlRKRQrFYr48eP58iRI0yePPmyfbNvqr777rtC/yc6bNiwK7pxuxbff/89aWlpzJ8/n6eeeop77rmH8PDwPBNYZrj++usB8twVpqh2isl+j/j4+Bzt6enp7Nu3z/F8tiZNmvDqq6+yatUqVq9eTUJCAtHR0Y7n3dzc6NChAxMnTmTHjh28+eabLFu2jOXLlxdJvCIiIq7AVe+HvLy86NatG7GxsSQlJTFnzhzuvPNO/P39HX3mzp3Lo48+ynvvvUe3bt2IiIigTZs2ee6YV5Drr7+eo0eP5krMXXpfcfr0aZYuXcrw4cMZM2YMDzzwABERETmWumWzWCxX9P6XvhfArl27HM8Xhxo1auDj45NvLG5ubgQFBTnaqlatSv/+/Zk5cyaHDh2iadOmuWbG3Xjjjfz73/8mNjaW7du3k56eznvvvefsUxExjZJSIlJoYWFhtGzZkkmTJnH+/PnL9s2+qRo7dmyhxr74xm3z5s1FEG3+sv9advFfx86ePctnn33m1PctrFq1anHzzTfzxRdf5LjZW7lyJdu2bSuS9wgPD8fT05MPP/wwx9chJiaGs2fP0qlTJwCSk5PJzMzM8domTZrg5uZGWloaYEzLv1Tz5s0BHH1ERERKC1e9H+rduzcZGRk89dRTHD9+PMfSPTDufy6dGfTRRx9d1azme+65h8zMTD7++GNHm81m46OPPsr1npB7RtKkSZNyjenr6wtQqCTZPffcw4YNG1i7dq2jLSUlhU8++YTg4GAaNWpU2FO5JlarlY4dO/Ldd985dmUEY3fAGTNm0KZNGypWrAjAyZMnc7y2fPny1K1b13GvlJqamuv76cYbb6RChQq6n5JSzd3sAESkZHnhhRfo3r07n3/+OU8//XS+/SpVqsTQoUOv6C992Vsob9myxXFj4gwdO3bE09OTzp0789RTT/HXX38xdepUatasydGjR532vldi3Lhx3H///bRu3Zr+/ftz+vRpJk+ezM0331zgcoFsx48f54033sjVXqdOHXr37s2IESMYM2YMd911F/fddx/x8fH83//9H7fddht9+vQBYNmyZQwePJju3btTr149MjMz+fLLL7FarTz44IOAUSNh1apVdOrUieuvv55jx47xf//3f9SuXTtHAVIREZHSwhXvh9q1a0ft2rX57rvvKFeuHF27ds3x/L333suXX35JpUqVaNSoEWvXrmXJkiVUq1at0O+RrXPnzrRu3Zrhw4ezf/9+GjVqxLx583LViKpYsaKjNlJGRgaBgYHExsayb9++XGOGhIQA8Morr9CzZ088PDzo3Llznl+D4cOHM3PmTO6++26GDBlC1apVmT59Ovv27eN///tfjk1cisK0adMcSw4vNnToUN544w3i4uJo06YNzzzzDO7u7vznP/8hLS2NCRMmOPo2atSIsLAwQkJCqFq1Kr/++itz585l8ODBAOzevZsOHTrw0EMP0ahRI9zd3fnmm29ISkrKsQxTpLRRUkpErkjXrl258cYbeffddxkwYEC+a/TB+OvgpEmTCl3EsnLlygwbNszpS/jq16/P3LlzefXVV3n++efx9/dn4MCB1KhRg8cee8yp711YnTt3ZubMmYwePZrhw4dz00038fnnnzN9+nR+//33Qo1x7NgxXnvttVztHTp0oHfv3owePZoaNWowefJknnvuOapWrcqTTz7JuHHj8PDwAKBZs2ZERkby/fffk5CQgI+PD82aNePHH3907Jxz3333sX//fqZNm8aJEyeoXr067dq1Y8yYMY7d+0REREoTV7wfcnNz4+GHH+add96hc+fOVKhQIcfzH3zwAVarla+++orz58/TunVrlixZkucuxYV5r/nz5zNs2DD++9//YrFYuO+++3jvvfe45ZZbcvSdMWMGzz77LFOmTMFut9OxY0d+/PFHatWqlaPfbbfdxuuvv050dDSLFi0iKyuLffv25ZmU8vPz4+eff+all17io48+4vz58zRt2pTvv//eMdu7KF08I+xi/fr1o3HjxqxevZoRI0Ywfvx4srKyCA0N5b///S+hoaGOvkOGDGH+/PnExsaSlpbG9ddfzxtvvMELL7wAQFBQEA8//DBLly7lyy+/xN3dnQYNGvD11187/hAoUhpZ7K5aWVdERHJp3rw5NWrUIC4uzuxQRERERERErolqSomIuKCMjIxctZxWrFjBli1bCAsLMycoERERERGRIqSZUiIiLmj//v2Eh4fTp08fatWqxa5du4iOjqZSpUps3779quo/iIiIiIiIuBLVlBIRcUFVqlQhJCSETz/9lOPHj+Pr60unTp146623lJASEREREZFSQTOlRERERERERESk2KmmlIiIiEgpMGXKFIKDg/H29iY0NJQNGzbk2zcsLAyLxZLrcfGuVf369cv1/F133VUcpyIiIiJlhJbviYiIiJRws2fPJioqiujoaEJDQ5k0aRKRkZHEx8dTs2bNXP3nzZtHenq64/OTJ0/SrFkzunfvnqPfXXfdxWeffeb43MvLy3knISIiImWOklJXKSsriyNHjlChQgUsFovZ4YiIiEgxsdvtnDt3jlq1auHm5hqTzidOnMiAAQPo378/ANHR0SxYsIBp06YxfPjwXP2rVq2a4/NZs2bh4+OTKynl5eWFv7//Vcel+yUREZGyqbD3S0pKXaUjR44QFBRkdhgiIiJikkOHDlG7dm2zwyA9PZ2NGzcyYsQIR5ubmxvh4eGsXbu2UGPExMTQs2dPfH19c7SvWLGCmjVrUqVKFe68807eeOONy262kJaWRlpamuPzhIQEGjVqdIVnJCIiIqVFQfdLSkpdpQoVKgDGF7hixYpFOnZGRgaxsbF07NgRDw+PIh1brp2uj+vStXFtuj6uTden8JKTkwkKCnLcC5jtxIkT2Gw2/Pz8crT7+fmxa9euAl+/YcMGtm/fTkxMTI72u+66i65du1KnTh3+/PNPXn75Ze6++27Wrl2L1WrNc6zx48czZsyYXO2ffvopPj4+V3BWIiIiUpKlpqbyxBNPFHi/pKTUVcqegl6xYkWnJKV8fHyoWLGifjFwQbo+rkvXxrXp+rg2XZ8rV1qWo8XExNCkSRNatmyZo71nz56O4yZNmtC0aVNuvPFGVqxYQYcOHfIca8SIEURFRTk+z07gdenSxSn3S3FxcUREROh71gXp+rg2XR/XpWvj2nR9Ci85OZknnniiwPslJaVERERESrDq1atjtVpJSkrK0Z6UlFRgPaiUlBRmzZrF2LFjC3yfG264gerVq7Nnz558k1JeXl55FkP38PBw2s27M8eWa6fr49p0fVyXro1r0/UpWGG/Pq5RnVNEREREroqnpychISEsXbrU0ZaVlcXSpUtp1arVZV87Z84c0tLS6NOnT4Hvc/jwYU6ePElAQMA1xywiIiICSkq5HJsNVq60sGpVICtXWrDZzI5IREREXF1UVBRTp05l+vTp7Ny5k4EDB5KSkuLYja9v3745CqFni4mJoUuXLrmKl//111+88MILrFu3jv3797N06VLuv/9+6tatS2RkZLGck4hIgbJskLQC9s80PmbplyeRkkbL91zIvHkwdCgcPuwOtGDiRKhdGz74ALp2NTs6ERERcVU9evTg+PHjjBw5ksTERJo3b86iRYscxc8PHjyYazvm+Ph41qxZQ2xsbK7xrFYrW7duZfr06Zw5c4ZatWrRsWNHXn/99TyX54mIFLtD82DjUEg9/E+bT20I+QCC9MuTSEmhpJSLmDcPunUDuz1ne0KC0T53rhJTIiIikr/BgwczePDgPJ9bsWJFrrb69etjv/TG44Jy5cqxePHiogxPRKToHJoHq7sBl/wblppgtLedq8SUSAmh5XsuwGYzZkjldV+Y3TZsGFrKJyIiIiIiZVuWzZghdWlCCv5p2zhMS/lESgglpVzA6tVw+HD+z9vtcOiQ0U9ERERERKTMOr4655K9XOyQesjoJyL5c5GabFq+5wKOHi3afiIiIiIiIqXS34X8paiw/UTKIheqyaaZUi6gsDsrawdmEREREREp08oV8peiwvYTKWuya7JdOuMwuybboXnFGo6SUi6gbVtjlz2LJf8+gYFGPxERERERkTKrRltjRgeX+eXJJ8joJyI5uWBNNiWlXIDVCh98YBznl5jy8oK//iq+mERERERERFyOm9VYYnQ5zcYZ/UQkJxesyaaklIvo2hXmzjVmRF3M3x8qVoS9e6FzZ0hNNSc+ERERERERlxDUFUJjcrdbLiSijq8p3nhESgoXrMmmpJQL6doV9u+HuLhMoqJ+JS4uk8OHYcUKqFTJ2H2vWzdITzc7UhERERERERNlLzEpXxf+NQM6LIf2i422Pf+BxGXmxSbiqlywJpuSUi7GaoV27ezccUcC7drZsVrhlltgwQIoVw5+/BH69AGbObs1ioiIiIiImC/hB+NjcC8Ifhj8wsC/A9z0jNG+/gnIUP0TkRxqtAWvmpfpYCn2mmxKSpUQrVvDN9+AhwfMmQNPPQX2vGqTiYiIiIiIlGa2dDh6YVZU4L05n2v+FvheDyn7YMvLxR+biEvLAneffJ67MPswZFKx1mRTUqoEiYyEmTPBzQ1iYuD555WYEhERERGRMubYSsj8C7z9oWpIzuc8KkDLqcbx7o/gWPEVbBZxebsmQsp+cC+fe4meT21oO9eo2VaMlJQqYR580EhIAUycCK+/bm48IiIiIiIixSp76V5gJ7Dk8SttQATc+LhxvP5xyPy7+GITcVXJf8C20cZxiylw/yGjFlt2Tbb79hV7QgqUlCqR+vWDDy7sgjpq1D/HIiIiIiIipZrdDgnfG8e17s2/3y3vQrlacO4P2DayeGITcVX2LNgwAGznwT8C6jxiLNHzC/unJlsxLtm7mJJSJdSQITB2rHE8bBh89pmp4YiIiIiIiDhf8i6jXpSbJ/iH59/PszK0/I9xvGsinFhfLOGJuKQ/Y4xlr1Yf4+cie/dKF6CkVAn26qsQFWUcP/EE/O9/5sYjIiIiIiLiVNmzpPzuBI/yl+8beC8E9zFmiax/DGxpzo9PxNWkHoHfXjCOm70B5euYG88lSkRSasqUKQQHB+Pt7U1oaCgbNmzIt29YWBgWiyXXo1OnTo4+8+bNo2PHjlSrVg2LxcLmzZuL4SyKnsUC774Ljz8OWVnw8MOweLHZUYmIiIiIiDiJo57UZZbuXSzkA/D2g7M7YLsK8koZtPFZyDgLVW+DekPMjiYXl09KzZ49m6ioKEaNGsWmTZto1qwZkZGRHDt2LM/+8+bN4+jRo47H9u3bsVqtdO/e3dEnJSWFNm3a8PbbbxfXaTiNxQL/+Q889BBkZMADD8CaNWZHJSIiIiIiUsTSTsGJn4zjWp0u3zebV1W47f+M4x1vwalNzolNxBUdmmc8LO4Q+qlpdaMux+WTUhMnTmTAgAH079+fRo0aER0djY+PD9OmTcuzf9WqVfH393c84uLi8PHxyZGUeuSRRxg5ciTh4ZdZg1yCWK3w5Zdw993w99/QqRNs0r+1IiIiIiJSmhz50ViKV+lmKB9c+NcFdYXrHgK7Ddb1B1u600IUcRnpZ+CXQcZxo5egSlNTw8mPu9kBXE56ejobN25kxIgRjjY3NzfCw8NZu3ZtocaIiYmhZ8+e+Pr6XlMsaWlppKX9swY5OTkZgIyMDDIyMq5p7Etlj3cl41osMHMmdO5sZfVqNyIj7SxblkmDBkUamnB110eKh66Na9P1cW26PoWnr5GIiEmOZC/d63zlr23xESQthTNbYcfb0OS1oo1NxNX89iKcT4QK9eDmV82OJl8unZQ6ceIENpsNPz+/HO1+fn7s2rWrwNdv2LCB7du3ExMTc82xjB8/njFjxuRqj42NxcfH55rHz0tcXNwVv2bgQHeOHGnNn39Wpn37TMaNW42f399OiE6u5vpI8dC1cW26Pq5N16dgqampZocgIlL2ZGXAkUXGcWHrSV3MuyaEfAQ/94LfX4egLlC5SZGGKOIyklbAn1ON49CpYPU2NZzLcemk1LWKiYmhSZMmtGzZ8prHGjFiBFHZW91hzJQKCgqiY8eOVKxY8ZrHv1hGRgZxcXFERETg4eFxxa8PC4M777Sza1c53nkngmXLMvH3L9IQy7RrvT7iPLo2rk3Xx7Xp+hRe9mxpEREpRsd/gowz4FUdqoVe3RjX94SDs+Hwd7DuMei4FtxK9a/EUhZl/g3rBxjHdZ+GmneYG08BXPonsHr16litVpKSknK0JyUl4V9AliUlJYVZs2YxduzYIonFy8sLLy+vXO0eHh5Ou3m/2rEDAmDJEmjbFvbssXDPPR6sXAlVqzohyDLMmddero2ujWvT9XFtuj4F09dHRMQE2bvu1brn6os1Wyxw28eQtBJO/Qq73jNq7YiUJtvHwl97oFwtaP6W2dEUyKULnXt6ehISEsLSpUsdbVlZWSxdupRWrVpd9rVz5swhLS2NPn36ODtMlxQYaCSmAgJg+3ajCPq5c2ZHJSIiIiIichUc9aSuYunexcoFQMgk43jrKDhbcFkYkRLj1G+w8x3j+LaPwbOSufEUgksnpQCioqKYOnUq06dPZ+fOnQwcOJCUlBT69+8PQN++fXMUQs8WExNDly5dqFatWq7nTp06xebNm9mxYwcA8fHxbN68mcTEROeeTDG74QaIizNmSG3YAF26wPnzZkclIiIiIiJyBZL/gOR4Y1t7/47XPl6dvhBwN2SlwfrHIMt27WOKmC0rE9Y/YewyeV13qH2f2REVissnpXr06MG7777LyJEjad68OZs3b2bRokWO4ucHDx7k6NGjOV4THx/PmjVrePzxx/Mcc/78+dxyyy106tQJgJ49e3LLLbcQHR3t3JMxQePGsGgRVKgAy5bBQw+BNg0SEREpfaZMmUJwcDDe3t6EhoayYcOGfPuGhYVhsVhyPbLvjS719NNPY7FYmDRpkpOiFxG5jOxZUjXbFc3MD4sFWv4H3CvAibWw+6NrH1PEbLveh9ObwLMKhHxodjSF5tI1pbINHjyYwYMH5/ncihUrcrXVr18fu92e73j9+vWjX79+RRSd67vtNvj+e7jrLuNjv37w5Zfg5vIpSRERESmM2bNnExUVRXR0NKGhoUyaNInIyEji4+OpWbNmrv7z5s0jPT3d8fnJkydp1qwZ3bt3z9X3m2++Yd26ddSqVcup5yAikq+EIlq6dzHfILj1XdjwFGx5GQI7Q4Ubi258keJ0bg9sG2kc3/IelCs5O50pLVFGtGsHc+eCuzvMmAGDBsFl8nYiIiJSgkycOJEBAwbQv39/GjVqRHR0ND4+PkybNi3P/lWrVsXf39/xiIuLw8fHJ1dSKiEhgWeffZavvvpKBd5FxBzpZ+HYKuO4KJNSADcOAL87wfY3rH8c7FlFO75IcbDbjeSq7bzx/XxDP7MjuiJKSpUhnToZM6QsFoiOhpdfNjsiERERuVbp6els3LiR8PBwR5ubmxvh4eGsXbu2UGPExMTQs2dPfH19HW1ZWVk88sgjvPDCCzRu3LjI4xYRKZSji8GeCRUbQIW6RTu2xQKhn4LVB46thD3/KdrxRYrD3s8gaRlYy0HLT4zv6xKkRCzfk6LTsyckJ8NTT8Fbb0GlSjB8uNlRiYiIyNU6ceIENpvNUW8zm5+fH7t2Fbyr1IYNG9i+fTsxMTE52t9++23c3d0ZMmRIoWNJS0sjLS3N8XlycjIAGRkZZBRxUcvs8Yp6XCkauj6urSRdH+vh+bgBNv97yHJGvF61cWvyJtbNz2H/7UUya0SA7/VF/z6FVJKuTVnkctfnfCLum/6NBbA1HkWW93UuU0S6sF8jJaXKoCefNBJTL7wAI0ZAxYrwzDNmRyUiIiJmiImJoUmTJrRs2dLRtnHjRj744AM2bdqE5Qr+4jp+/HjGjBmTqz02NhYfH58iifdScXFxThlXioauj2tz+etjt3FX6ny8gLUHq3IyYaGT3ud62rg1pFrmTk4v6sZa79GmzzZx+WtTxrnK9WlxfgKBtjOccbuRVXtuwv6nk35GrkJqamqh+ikpVUY9/zycPQtvvGHUl6pYEfr0MTsqERERuVLVq1fHarWSlJSUoz0pKQl//8sXOk1JSWHWrFmMHTs2R/vq1as5duwY1113naPNZrPx73//m0mTJrF///48xxsxYgRRUVGOz5OTkwkKCqJjx45UrFjxCs/s8jIyMoiLiyMiIkL1rlyQro9rKynXx3LiZ9yXn8PuUZnQTs+BmxNjPVcfe2wINbO20KnRMex1+jvvvS6jpFybssqVro8lYT7uP/+M3WLFt8NM7q7c3NR4LpU9W7ogSkqVYWPHGompjz4yduSrUAHuv9/sqERERORKeHp6EhISwtKlS+nSpQtg1INaunRpvrsXZ5szZw5paWn0ueQvU4888kiOGlUAkZGRPPLII/Tvn/8val5eXnh5eeVq9/DwcNrNuzPHlmun6+PaXP76JC0CwFLrbjy8nDPb0qFqI2j2Bvz2PO5bXoDancAn0LnveRkuf23KONOvT/pZ+M1YXm9p+AIeNW4zL5Z8FPbro6RUGWaxwKRJRmLqiy/goYdg4ULo0MHsyERERORKREVF8eijj9KiRQtatmzJpEmTSElJcSSQ+vbtS2BgIOPHj8/xupiYGLp06UK1atVytFerVi1Xm4eHB/7+/tSvX9+5JyMiki3hB+NjUe+6l5/6w+Dg13Byg7GbWbvvTV/GJ5KnzcPh7yNQ4Sa4eaTZ0VwTJaXKODc3iImBc+fgm2+MmVJLlsDtt5sdmYiIiBRWjx49OH78OCNHjiQxMZHmzZuzaNEiR/HzgwcP4uaWc9Pl+Ph41qxZQ2xsrBkhi4hc3l/74ex2sFgh4K7ieU83K9z+Gfx4CxxZAPu/gjqqcSIu5tgq2BNtHLecCu7lzI3nGikpJbi7w8yZ0LkzxMXB3XfDypXQtKnZkYmIiEhhDR48ON/leitWrMjVVr9+fex2e6HHz6+OlIiIU2TPkqrRGryqFt/7VmoETUbBlldg4xDwD4dyl6/PJ1JsbOdh/QDj+MYB4NfO3HiKgFvBXaQs8PIyZkq1agVnzkDHjvDHH2ZHJSIiIiIiZdKRC0mpWsW0dO9iDV+AKrdA+mn4dRBcQQJfxKm2vw7ndkO5ALhlgtnRFAklpcTB19eoKdWsGSQlQXg4HDpkdlQiIiIiIlKmZPwFScuN4+KqJ3UxNw9jGZ/FHQ7Ng0Nziz8GkUud3gI7LiSiWkwBz8qmhlNUlJSSHCpXhthYqFcPDh40ElPHjpkdlYiIiIiIlBmJcZCVDuVvhIoNzImhSjNo/LJx/MsgOH/cnDhEALJssP4JsGdCUFcIesDsiIqMklKSS82aRm2poCDYvRsiI40lfSIiIiIiIk538a57Zu5+1/gVqHQzpB2HjUPNi0Mk/gM49St4VIKQj8yOpkgpKSV5uu46Yxe+mjVh82bo1AlSUsyOSkRERERESjV7lrHzHZizdO9iVs8Ly/jc4MBMOPydufFI2fTXXtj6qnF8y7vgU8vceIqYklKSr3r1jKV8lSvDzz/DAw9AWprZUYmIiIiISKl18lc4nwTuFaDGHWZHA9VaGIXPATY8bRQ/FykudrvxfWf7G2qGwY2Pmx1RkVNSSi6rWTOj+LmPj7Gkr1cvyMw0OyoRERERESmVsnfdC4g0Ziq5giajoWJ9OJ8Im6LMjkbKkn1fGDXWrN7Q8hNzl7M6iZJSUqBWreC778DTE+bNgyeegKwss6MSEREREZFS5+J6Uq7C6g2h0wAL7P0cjvxodkRSFvydBJueM46bjIaKN5kajrMoKSWFEh4Os2eD1QrTp8OwYcZMQhERERERkSKRehhO/wZYoNbdZkeTU41/Qf1hxvGGJyEj2dRwpAzYONRYLlqlOTQovTP0lJSSQuvSBT77zDj+6CMYNcrUcEREREREpDRJuFDgvPrt4F3T3Fjy0uwNKH+jkTz77QWzo5HS7PD3cHA2WKwQGgNuHmZH5DRKSskVeeQRmDzZOH79dXjvPXPjERERERGRUsIVl+5dzN3HSBAA7PkEEpeaG4+UThnJ8OszxnGDKKh6q7nxOJmSUnLFBg2CN980jp9/HqZONTceEREREREp4TJTIWmJcVzLRZNSAH7t4KYLCYP1T0DGX+bGI6XP5hHGbLzyNxq1pEo5JaXkqowYAS9cmLH61FNGvSkREREREZGrkrQMbOfB5zqo3MTsaC6v+Vvgez2k7IctL5sdjZQmx3+CP/7POG75iTE7r5RTUkquisUCb79tJKTsdujTBxYuNDsqEREREREpkS5euufq2957VICWF5aL7P4Ijq02Nx4pHWxpxuw7gBseA/87zY2nmCgpJVfNYoEpU+DhhyEzEx58EFauNDsqEREREREpUex2168ndamACLjxceN4/ePG8kORa/H7m5C8C7z94NZ3zY6m2JSIpNSUKVMIDg7G29ub0NBQNmzYkG/fsLAwLBZLrkenTp0cfex2OyNHjiQgIIBy5coRHh7OH3/8URynUupYrTB9Otx7L5w/D507w6+/mh2ViIiIiIiUGKc3w98JYPUBv/ZmR1N4t7wH5QLh3B+wTVuTyzU4sw1+H28ct5gMnlXMjacYuXxSavbs2URFRTFq1Cg2bdpEs2bNiIyM5NixY3n2nzdvHkePHnU8tm/fjtVqpXv37o4+EyZM4MMPPyQ6Opr169fj6+tLZGQk58+fL67TKlU8PODrryEsDM6dg8hI+P13s6MSEREREZESIXuWVEAEWL3NjeVKeFaClv8xjndNhBPrzY1HSqYsG6wfAPZMqH0/BD1odkTFyuWTUhMnTmTAgAH079+fRo0aER0djY+PD9OmTcuzf9WqVfH393c84uLi8PHxcSSl7HY7kyZN4tVXX+X++++nadOmfPHFFxw5coRvv/22GM+sdClXDubPh9tug1OnICIC9u4Fmw1WrICZM42PNpvZkYqIiIiIiEs5ciEp5cq77uUnsBMEPwL2LFjX36gLJHIldk+Gk+vBoyK0mOL6NdWKmLvZAVxOeno6GzduZMSIEY42Nzc3wsPDWbt2baHGiImJoWfPnvj6+gKwb98+EhMTCQ8Pd/SpVKkSoaGhrF27lp49e+Y5TlpaGmlp//wDk5ycDEBGRgYZGRlXfG6Xkz1eUY/rbN7eRmKqQwd3duyw0KqVHTc3SEz854cqMNDOxIk2HnjAbmKk16akXp+yQNfGten6uDZdn8LT10hEpAj9nQgnL5RnCex0+b6uKmQSJMZC8k7YPhaavWl2RFJS/LUftr5iHDefAD6BpoZjBpdOSp04cQKbzYafn1+Odj8/P3bt2lXg6zds2MD27duJiYlxtCUmJjrGuHTM7OfyMn78eMaMGZOrPTY2Fh8f52zTGBcX55Rxne3557147rkwjh3zBnImnxISoEcPKy+99AutWh01Jb6iUlKvT1mga+PadH1cm65PwVJTVcxWRKTIHLmwhXfVFlAuwNxYrpZXVbjt/2D1g7DjbWP5VdVbzY5KXJ3dDr88DZkpUPMOqDvA7IhM4dJJqWsVExNDkyZNaNmy5TWPNWLECKKiohyfJycnExQURMeOHalYseI1j3+xjIwM4uLiiIiIwMPDo0jHLg42G7z8sjtnz9qBS6ceWrBY7Hz11W2MHp2J1WpGhNempF+f0kzXxrXp+rg2XZ/Cy54tLSIiRaCk7bqXn6CucN1DcPBrYxlf5C9g9TQ7KnFl+7+Co4vBzQtafgIWl6+u5BQunZSqXr06VquVpKSkHO1JSUn4+/tf9rUpKSnMmjWLsWPH5mjPfl1SUhIBAf9k4pOSkmjevHm+43l5eeHl5ZWr3cPDw2k3784c25l++gkuM+kMu93C4cOwbp0HYWHFFlaRK6nXpyzQtXFtuj6uTdenYPr6iIgUEVuasewNSn5SCqDFR5C0DM5shR1vQZORZkckrur8cdg0zDhuMhIq1jc1HDO5dCrO09OTkJAQli5d6mjLyspi6dKltGrV6rKvnTNnDmlpafTp0ydHe506dfD3988xZnJyMuvXry9wTCmco4VclXfwoHPjEBERERERF5a0wli6VK4WVCkFy928a0LIR8bx72/AmW3mxiOua+MwSDsJlZtCwxfMjsZULp2UAoiKimLq1KlMnz6dnTt3MnDgQFJSUujfvz8Affv2zVEIPVtMTAxdunShWrVqOdotFgvDhg3jjTfeYP78+Wzbto2+fftSq1YtunTpUhynVOoFFHIp+KBBMHAgrF1rLKcVEREREZEyxLHrXqfSs+PY9T2g9v2QlWEs48vKNDsicTUJC+HADGO5Xuin4Fa2Z2C79PI9gB49enD8+HFGjhxJYmIizZs3Z9GiRY5C5QcPHsTNLWduLT4+njVr1hAbG5vnmC+++CIpKSk8+eSTnDlzhjZt2rBo0SK8vb2dfj5lQdu2ULu2UdQ8v2ST1Qp//QXR0cajbl3o2xf69IE6dYo3XhERERERKWZ2e+mpJ3UxiwVu+xiSVsKpjbDrPWj0ktlRiavIOGcUNweoPwyq3WZqOK7A5WdKAQwePJgDBw6QlpbG+vXrCQ0NdTy3YsUKPv/88xz969evj91uJyIiIs/xLBYLY8eOJTExkfPnz7NkyRLq1avnzFMoU6xW+OAD4/jSP3hYLMZj1ixYssRIRPn6wp49MHIk3HADtGsHMTFw9mzxxy4iIlJSTZkyheDgYLy9vQkNDWXDhg359g0LC8NiseR6dOr0z3bso0ePpkGDBvj6+lKlShXCw8NZv359cZyKiJQFZ3+HlP1g9Qb/cLOjKVrlAiBkknG8dRScLXjneCkjtrwCqYfAtw40HVtw/zKgRCSlpOTp2hXmzoXAwJzttWsb7d26QYcOMH26URT9iy8gPNxIWK1aBU88Af7+8PDD8OOPkKlZryIiIvmaPXs2UVFRjBo1ik2bNtGsWTMiIyM5duxYnv3nzZvH0aNHHY/t27djtVrp3r27o0+9evWYPHky27ZtY82aNQQHB9OxY0eOHz9eXKclIqVZ9iwpvzvB3cfcWJyhTl8IuBuy0mD9Y5BlMzsiMdvxtbB7snHc8j/g7mtuPC5CSSlxmq5dYf9+WL4cZswwPu7bZ7RfrHx5eOQRiIszip+/9RY0bAjnzxszqu65x0hm/fvfsGWLKaciIiLi0iZOnMiAAQPo378/jRo1Ijo6Gh8fH6ZNm5Zn/6pVq+Lv7+94xMXF4ePjkyMp1atXL8LDw7nhhhto3LgxEydOJDk5ma1btxbXaYlIaXakFC7du5jFciHxUAFOrIXdH5kdkZjJlg4bngDsUOdRCMh7VVdZpKSUOJXVCmFhxoynsDDj88upXRteegl+/x1+/RWGDIHq1SEpCSZOhObNoVkzeO+9wu/yJyIiUpqlp6ezceNGwsP/Wf7i5uZGeHg4a9euLdQYMTEx9OzZE1/fvP9qm56ezieffEKlSpVo1qxZkcQtImXY+RNGogaMIuellW8Q3PqucbzlZTi3x9x4xDw7xsPZHcYOjbe+Z3Y0LsXlC51L2WSxQEiI8Xj3XVi0yFjiN38+bN0Kzz8PL74IHTsadanuvx98SuGsXxERkYKcOHECm83m2AQmm5+fH7t2FVzHZMOGDWzfvp2YmJhcz/3www/07NmT1NRUAgICiIuLo3r16vmOlZaWRlpamuPz5ORkADIyMsjIyCjsKRVK9nhFPa4UDV0f12b29bEc/h53exb2Sk3J9AyA0vx9cl0/rPtn43ZsGVnrHsfWLtbYdS0fZl8bubyruj7JO3Df/iYWILP5ROxuFUv39/wFhf0aKSklLs/DAzp3Nh6nT8PXXxsJqp9/NpJVixZBhQrQvbuRoGrbFtw0B1BERKRQYmJiaNKkCS1btsz1XPv27dm8eTMnTpxg6tSpPPTQQ6xfv56aNWvmOdb48eMZM2ZMrvbY2Fh8nPTXo7i4OKeMK0VD18e1mXV9WpyPIRDYnVqfXQsXmhJDcfLJ6kF7fsL9+Cq2zR/Cfo97CnyNfnZcW6Gvj91G2/MvU9WeQaK1Beu3+sK20v89D5CamlqofkpKSYlSpQo89ZTx+OMP+O9/jQTV/v0wbZrxuP56o0bVI4+ANlUUEZHSrnr16litVpKSknK0JyUl4e/vf9nXpqSkMGvWLMaOzXsHIF9fX+rWrUvdunW5/fbbuemmm4iJiWHEiBF59h8xYgRRUVGOz5OTkwkKCqJjx45UrFjxCs/s8jIyMoiLiyMiIgIPD48iHVuuna6PazP1+mRl4P5dXwBubDuEG6qFFvCC0sHyRypsfo6mtq9oFP48+Abn2U8/O67tSq+P257/w/pbPHb3ClSL/Jp7fGoXQ5SuIXu2dEGUlJIS66abYMwYGDUKfvrJSE59/TUcOABvvGE8br/dmD3VowdUrWp2xCIiIkXP09OTkJAQli5dSpcuXQDIyspi6dKlDB48+LKvnTNnDmlpafTp06dQ75WVlZVjed6lvLy88PLyytXu4eHhtF+unDm2XDtdH9dmyvVJXA2ZyeBVA3e/f112KVup0nAIJPwPy/E1eGwaBO0XGzVL8qGfHddWqOuTchC2vQqApflbeFSqUwyRuY7Cfv+WkX8BpDRzczOW7E2dComJ/+zYZ7XCunXwzDMQEAAPPgjffQfp6WZHLCIiUrSioqKYOnUq06dPZ+fOnQwcOJCUlBT69+8PQN++ffOc3RQTE0OXLl2oVq1ajvaUlBRefvll1q1bx4EDB9i4cSOPPfYYCQkJOXboExG5YgnZu+51KjsJKTDONXQaWL0hMQ725r07qpQSdjv8MhAy/4IareGmp82OyGVpppSUKuXKGbOievQwElQzZxozqDZvhnnzjEe1asZugH37QosWl/0DhYiISInQo0cPjh8/zsiRI0lMTKR58+YsWrTIUfz84MGDuF1ScDE+Pp41a9YQGxubazyr1cquXbuYPn06J06coFq1atx2222sXr2axo0bF8s5iUgpdeRCUqrWvebGYYaKN0HTN+C352FTFATcBT6BZkclznBgFhxZCG6e0HJq2UrAXiElpaTU8veH554zHlu3wpdfGjWoEhNh8mTj0aCBkZzq0weCgsyOWERE5OoNHjw43+V6K1asyNVWv3597HZ7nv29vb2ZN29eUYYnIgLJ8XDuD3DzgICOZkdjjvrD4OAcOLkeNjwF7b7XX8lLm/MnYOMQ47jxq1CpobnxuDil66RMaNoU3nkHDh0yduvr1cuYVbVrF7z8slEcvUMHmD4dzp3LfxybDVautLBqVSArV1qw2YrvHERERERESrTspXs1w8CjgqmhmMbNCrdPM2bQHFkA+78yOyIpapuiIO0EVLoZGr1kdjQuT0kpKVPc3SEyEr76ypgxNW0ahIUZS36XLYN+/YwZVo88AnFx5Eg6zZsHwcEQEeHOxIktiIhwJzjYaBcRERERkQI46kmVwaV7F6vUCJqMMo43DoG/E82NR4rOkcWw/0vAAqGfgtXT7IhcnpJSUmZVrAj9+8Py5bBvn7Fb3003QWqqscyvY0e47jp46SWYNAm6dYPDh3OOkZBgtCsxJSIiIiJyGemn4fhq47isJ6UAGr4AVW4xvi6/PGP8lVxKtoy/4JenjOP6Q6B6qLnxlBBKSolgzIB65RWIj/9nx74qVeDIEZgwwahLldf/E9ltw4ahpXwiIiIiIvk5shjsNmOWUPkbzI7GfG4ecPtnYHGHw98YdaakZNv6GqQcAN/rjYL2UihKSolcxGKB0FCYMgWOHjVmQLVuffnX2O1GrarnnoPZs41lgNu3w7FjSlSJiIiIiABle9e9/FRpBo1fNo5/HQznj5sbj1y9E+sh/gPj+LZo8ChvbjwliHbfE8mHlxc88ACcPw8//VRw/48+Mh4Xs1igWjWoUQNq1vzn48XHF3+sWhXcijFVbLPB6tVGAi4gANq2Bau1+N5fRERERMqArEw48qNxrKV7OTV+BQ7Ng7Pb4ddnsdR5gsDMVViO+UJAe6Mwurg2WzqsfwKwQ3AfqHWX2RGVKEpKiRQgIKBw/e64w0hCHTsGx4/DyZPGLKoTJ4zHzp0Fj2G1QvXqhU9iVa589TvIzpsHQ4fmrJNVuzZ88AF07Xp1Y4qIiIiI5HJiLaSfAs+qUL2V2dG4FqunsYxvcSgcnI37wdm0AFg5EXxqQ8gHEKSbc5e2c4KRVPSqDre+b3Y0JY6SUiIFaNvWSNYkJORdV8piMZ5ftiznLKPMTCMxdfz4P4mqiz9e2nb6tDFzKSnJeBSGh4eRnMorYZVXMqtCBSPeefOMAu2Xnk924fa5c5WYEhEREZEikr3rXq27wU2/guaSehDIyqM9AVZ3g7ZzlZhyVWd3wfbXjeOQD8C7urnxlED6F0GkAFarMXuoWzcjoXNxIid7ltKkSbmXvbm7g5+f8SiM9HRjRlVByavstnPnICPDKMZ+5Ejh3sPLy5iJdezY5Qu3P/MM3HyzkciqVKl4lxReLZsNVq60sGpVIL6+Ftq311JEEREREZegelL5y7LBxqH5PGkHLLBxGATer6V8rsaeBRsGQFY61LoHrn/Y7IhKJCWlRAqha1dj9lBey90mTSqaWUWenlCrlvEojPPnjSRVYZNYqamQlmbMhipIUhLUr28cWyzGMsEqVYyaV1fy0cfn6pcXXol/liK6Ay2YOFFLEUVERERcwl974ewOsFhVaycvx1dD6uHLdLBD6iGjn19YcUUlhbHnP3B8Dbj7wm0fF88vPqWQklIihdS1K9x/PyxfnsmPP27m7rub0769u2mzcby9ISjIeBRGSoqRpPrvf+G11wru7+lpzN6y242lhadPw969Vxajp2fuZFVhElqVKxtLEwtDSxFFREREXFj20r0abcGzsqmhuKS/jxZtPykeqYfht5eM42bjwfc6c+MpwZSUErkCViu0a2cnJSWBdu2alajlYb6+xqNNm8L1X7wYWrX6JyF16lTBHy8+ttmMpNaV1Mi6WIUKBSevKlWCwYPzX4poscCwYUYysSRdKxEREZFSIzsppV338laukLsqFbafOE+WDcuxlQRmrMK69i3IPGcU7r/pGbMjK9GUlBIpYwpbuL1tWyOR4+9vPK6E3Q5//VW4RNalH5OTjTHOnTMeBw9e/bna7XDoEKxeDWFhVz+OiIiIiFyFjGQ4tsI4Duxsaiguq0ZbY5e91ASMGlJ5KFfb6CfmOTQPNg7FPfWwsTviqQvt1z2kWl/XSEkpkTLmagu3XwmLxZjpVKECXH/9lb02MxPOnClcEis+3ngU5KhmO4uIiIgUv6NxkJUBFW6CivXMjsY1uVmNXdtWdwMs5JmY8qmlekVmOjTvwvXJ49psijKW7ml3xKtWAvbUgilTphAcHIy3tzehoaFs2LDhsv3PnDnDoEGDCAgIwMvLi3r16rFw4ULH8+fOnWPYsGFcf/31lCtXjn/961/88ssvzj4NEZeRXbg9MDBne+3a5tdgcnc3dgi86SYIDYW77oJevWDQIKMW1sSJ8Pnn8N13EB1duDG3bYOsPHbZFREREREn0q57hRPUFdrOBZ9Lbs69aoLFHU5ugK2FKAorRc+xO2I+s9jA2B0xy1ZcEZU6TktKHTp0iMMXbVO2YcMGhg0bxieffHJF48yePZuoqChGjRrFpk2baNasGZGRkRw7dizP/unp6URERLB//37mzp1LfHw8U6dOJfCi376feOIJ4uLi+PLLL9m2bRsdO3YkPDychMJsSyZSSnTtCvv3w/LlMGOG8XHfvpJVFDx7KWJBfzgaPx5CQiAurnjiEhEprKK6XxIRcTn2LEhYYByrnlTBgrrCffvJbBfHr15RZLaLgweOwO3TjOd/Hwf7vjI3xrLoSnZHlKvitKRUr169WL58OQCJiYlERESwYcMGXnnlFcaOHVvocSZOnMiAAQPo378/jRo1Ijo6Gh8fH6ZNm5Zn/2nTpnHq1Cm+/fZbWrduTXBwMO3ataNZs2YA/P333/zvf/9jwoQJ3HHHHdStW5fRo0dTt25dPv7442s/cZESxGo1ai09/LDxsaQVA89eigi5E1MWi/Ho3RsqVoTNm6FjR+Px22/FHqqISJ6K6n5JRMTlnNwAacfBoyLUVD2kQnGzYq/ZjgT3O7DXbGcs7avzCDQabjy//nE4sc7cGMsa7Y7odE6rKbV9+3ZatmwJwNdff83NN9/MTz/9RGxsLE8//TQjR44scIz09HQ2btzIiBEjHG1ubm6Eh4ezdu3aPF8zf/58WrVqxaBBg/juu++oUaMGvXr14qWXXsJqtZKZmYnNZsPb2zvH68qVK8eaNWvyjSUtLY20tDTH58kXqjFnZGSQkZFR4LlciezxinpcKRq6Pq6lc2eYNctCVJSVhIR/MlOBgXbee8/GAw/YOXEC3nrLjY8/diMuzsKSJXYeftjOmDG2K655JVdPPzuuTden8Irya1QU90siIi4pe9e9gLvAzcPcWEq6Zm9C8k44/B2s6gKRG4w6RuJ82h3R6ZyWlMrIyMDLywuAJUuWcN999wHQoEEDjhay6vCJEyew2Wz4+fnlaPfz82PXrl15vmbv3r0sW7aM3r17s3DhQvbs2cMzzzxDRkYGo0aNokKFCrRq1YrXX3+dhg0b4ufnx8yZM1m7di1169bNN5bx48czZsyYXO2xsbH4+PgU6nyuVJzWGrk0XR/X4eUFH34IO3ZU4/Rpb6pUOU+jRiexWiG7nNydd0KjRj589VVDVq+uzYwZFr7+2k6nTvvo1m03FSroF/Hiop8d16brU7DU1NQiG6so7pdERFxSdlJKS/euncUNWv0X4trAmS2w8j6IWAMe5c2OrPSzepNvAXownvPR7ojXwmlJqcaNGxMdHU2nTp2Ii4vj9ddfB+DIkSNUq1bNWW9LVlYWNWvW5JNPPsFqtRISEkJCQgLvvPMOo0aNAuDLL7/kscceIzAwEKvVyq233srDDz/Mxo0b8x13xIgRREVFOT5PTk4mKCiIjh07UrFixSI9h4yMDOLi4oiIiMDDQ39VcDW6Pq7rrrsKvjaPPQYbN2YyYoQbK1ZY+e67uqxceSMvvZTFoEFZXDKJUoqQfnZcm65P4WXPli4KZt0viYg4VcpBI3licYOAu82OpnTwKA/t5sPi24yv7dpHoO3/jK+xOMfZXbDyXv5JSF2anLqwSiNkkrHUUq6K05JSb7/9Ng888ADvvPMOjz76qKOm0/z58x3T1AtSvXp1rFYrSUlJOdqTkpLw9/fP8zUBAQF4eHhgvag4TsOGDUlMTCQ9PR1PT09uvPFGVq5cSUpKCsnJyQQEBNCjRw9uuOGGfGPx8vJy/CXzYh4eHk67eXfm2HLtdH1cV0HX5vbbYdkyWLQIXnwRtm+3MGKElY8/tvLGG0YdKjf9/+40+tlxbbo+BSvKr09R3C+JiLicIxcKnFdvBd7VzY2lNPG9Dtp+C0vD4PC3xo58zd40OahSKuUgLI+AtJNQrSXUGwJbhucseu5T20hIBZWgnaJckNN+7QoLC+PEiROcOHEiR1HyJ598kuhC7uPu6elJSEgIS5cudbRlZWWxdOlSWrVqledrWrduzZ49e8i6aP/33bt3ExAQgKenZ46+vr6+BAQEcPr0aRYvXsz9999/JacoIiWYxQJ3320UQP/sM2MXv4MHoW9fuPVWiI01O0IRKQuK4n5JRMTlZC/dq6Wle0WuRisIjTGOfx8H+/5rbjyl0fnjsLyjkYCq2BDaLYA6vXPvjnjfPiWkioDTklJ///03aWlpVKlSBYADBw4wadIk4uPjqVmzZqHHiYqKYurUqUyfPp2dO3cycOBAUlJS6N+/PwB9+/bNUQh94MCBnDp1iqFDh7J7924WLFjAuHHjGDRokKPP4sWLWbRoEfv27SMuLo727dvToEEDx5giUnZYrdCvH+zeDW+9ZezUt2ULREZCRIR26hMR5yqq+yUREZeRmQKJFyYVBHY2N5bSqk6fi3bkewKO570JmFyFjHOw4h5Ijgef6+DO2H9m++W1O6JcM6clpe6//36++OILAM6cOUNoaCjvvfceXbp04eOPPy70OD169ODdd99l5MiRNG/enM2bN7No0SJH8fODBw/mKAQaFBTE4sWL+eWXX2jatClDhgxh6NChDB8+3NHn7NmzDBo0iAYNGtC3b1/atGnD4sWLtVxBpAwrVw5eegn27oXnngMPD1iyxJg11acP7N9vdoQiUhoV1f2SiIjLSFwKWWngGwyVGpkdTenV7E2o3cX4Wq/uYiw3k2tjSzN2Nzz1K3hVNxJSPrXNjqrUc1pSatOmTbRta1Sgnzt3Ln5+fhw4cIAvvviCDz/88IrGGjx4MAcOHCAtLY3169cTGhrqeG7FihV8/vnnOfq3atWKdevWcf78ef78809efvnlHDWmHnroIf7880/S0tI4evQokydPplKlSld/siJSalSrBhMnQnw89OpltH31FdSvD88/D6dOmRufiJQuRXm/JCLiEi7edc9iMTeW0sziBq2+hMrN4PwxY0e+jL/MjqrkyrLBz70gaRm4l4f2i6BifbOjKhOclpRKTU2lQoUKAMTGxtK1a1fc3Ny4/fbbOXDggLPeVkSkSNSpYySjfv0V7rwT0tPhvffgxhvhnXfg/HmzIxSR0qAo75emTJlCcHAw3t7ehIaGsmHDhnz7hoWFYbFYcj06deoEGLsxvvTSSzRp0gRfX19q1apF3759OXLkyNWfrIiUfvYsOJKdlNLSPafL3pHPu+Y/O/LZswp+neRkt8MvT8OheeDmaXxNq4aYHVWZ4bSkVN26dfn22285dOgQixcvpmPHjgAcO3aMihUrOuttRUSKVEiIsYzvxx+hSRM4c8bYsa9ePfjiC7DZzI5QREqyorpfmj17NlFRUYwaNYpNmzbRrFkzIiMjOXbsWJ79582bx9GjRx2P7du3Y7Va6d69O2AkyzZt2sRrr73Gpk2bmDdvHvHx8dx3333XftIiUnqd/g3+PgruvlCzndnRlA3ZO/K5eRo78m151eyISp4tL8Ofnxqzz1rPAr/2ZkdUpjgtKTVy5Eief/55goODadmypWO3vNjYWG655RZnva2ISJGzWOCuu4yi559/buzUd+gQPPqokbRavNj4A4uIyJUqqvuliRMnMmDAAPr370+jRo2Ijo7Gx8cnx45+F6tatSr+/v6OR1xcHD4+Po6kVKVKlYiLi+Ohhx6ifv363H777UyePJmNGzdy8KDqlohIPrKX7vl3BKuXubGUJRfvyLdjvHbkuxI734UdbxnHLadC0APmxlMGuTtr4G7dutGmTRuOHj1Ks2bNHO0dOnTggQd0oUWk5LFajUTUQw/Bhx/C+PHGTn133QXh4TBhAijnLiJXoijul9LT09m4cWOO3Yjd3NwIDw9n7drC7cgUExNDz5498fX1zbfP2bNnsVgsVK5cOd8+aWlppKWlOT5PTk4GjOWAGRkZhYqlsLLHK+pxpWjo+rg2Z10f6+HvcQMy/e/Grmt/Va762tTugVuDbVh3TcC+/nFs5a7HXu12J0RYelj2Tcf9txcAsDUdT9Z1j0ABX3f921Z4hf0aOS0pBTj++nb48GEAateuTcuWLZ35liIiTpe9U98TT8C4cTB58j879fXuDW+8AcHBZkcpIiXFtd4vnThxApvN5tiZOJufnx+7du0q8PUbNmxg+/btxMTE5Nvn/PnzvPTSSzz88MOXXVY4fvx4xowZk6s9NjYWHx+fAmO5GnFxcU4ZV4qGro9rK8rr4511isi/NwKwZIcnaTsXFtnYZdFVXRv77bS0hhJgW0/mss6sKvcOf7vVLPrgSgH/zHW0TJsAwB8eD7Djz4bwZ+G/Z/VvW8FSU1ML1c9pSamsrCzeeOMN3nvvPf76y9gFoEKFCvz73//mlVdewc3NaSsHRUSKRbVqRvHzZ5+FV181CqN/9RXMmQODB8Mrr0DVqmZHKSKuzBXul2JiYmjSpEm+ibCMjAweeugh7HY7H3/88WXHGjFiBFFRUY7Pk5OTCQoKomPHjkVeUzQjI4O4uDgiIiLw8PAo0rHl2un6uDZnXB/L3mmwEbKq3kaHDr2KZMyy6JqvTWYY9mVheJ/dSoTnR2TeudLYTU4cLMdWYF39PhayyKrTn+CQaIILuVOk/m0rvOzZ0gVxWlLqlVdeISYmhrfeeovWrVsDsGbNGkaPHs358+d58803nfXWIiLFKjgY/vtfeO45YwbV0qUwcSJMmwYjRhhJq3LlzI5SRFxRUdwvVa9eHavVSlJSUo72pKQk/P39L/valJQUZs2axdixY/N8PjshdeDAAZYtW1ZgYsnLywsvr9x1ZDw8PJx28+7MseXa6fq4tiK9Pkk/AuAW2Bk3XfNrdtXXxqMKhH0Pi1tiObsNj1/6Q9t5RhFvgVMb4acHISsNaj+AW+gnuLldeVpE/7YVrLBfH6d9Z06fPp1PP/2UgQMH0rRpU5o2bcozzzzD1KlT+fzzz531tiIipgkJgbg4WLQImjY1dup76SWoXx+mT9dOfSKSW1HcL3l6ehISEsLSpUsdbVlZWSxdutRROD0/c+bMIS0tjT59+uR6Ljsh9ccff7BkyRKqVat2RecmImWI7TwcvbCcqXZnc2ORCzvyfQNuXnD4O9jyitkRuYbkeFh+F2SeM3bYaz0DriIhJUXLaUmpU6dO0aBBg1ztDRo04NSpU856WxERU1ksEBkJmzYZO/UFBRk79fXrZ9ScWrRIO/WJyD+K6n4pKiqKqVOnMn36dHbu3MnAgQNJSUmhf//+APTt2zdHIfRsMTExdOnSJVfCKSMjg27duvHrr7/y1VdfYbPZSExMJDExkfT09Cs8SxEp9ZKWgy0VygVC5WYF9xfny7Ej31uw70tz4zFb6mFY1hHSTkDVELjjW7B6mx2V4MSkVLNmzZg8eXKu9smTJ9O0aVNnva2IiEvI3qkvPt7Yla9SJdi6Fe6+GyIijKSViEhR3S/16NGDd999l5EjR9K8eXM2b97MokWLHMXPDx48yNGjR3O8Jj4+njVr1vD444/nGi8hIYH58+dz+PBhmjdvTkBAgOPx888/X+FZikipl/CD8THwXuMvdOIa6vSGxi8bx+ufgOOF25G11Ek7aSSkUg9ChXoQ9iN4FG2dQ7l6TpurNmHCBDp16sSSJUscU8fXrl3LoUOHWLhQOzGISNlQrhy88AI8/rixU99HHxk1p0JCoFcvY6e+OnXMjlJEzFKU90uDBw9m8ODBeT63YsWKXG3169fHns/UzeDg4HyfExHJwW6HhO+N40At3XM5TV+Hszvh8DewugtEbgDf682Oqvhk/AUr7oHkneBTG+6MA+8aZkclF3HaTKl27dqxe/duHnjgAc6cOcOZM2fo2rUrv//+O19+WcanDopImVO1Krz7rjFzqndvo23GDGjQAKKi4OTJnP1tNlixAmbOND6qHpVI6aT7JREp8c5sg9RDYC0HfneaHY1cyuIGrb6AKs3h/DFYeZ+RqCkLbGmwuiuc3ABe1aB9rFFvS1yKU6t61apVK9euMVu2bCEmJoZPPvnEmW8tIuKSsnfqi4qCF180Zk29//4/O/UNGQI//ghDh8Lhw/+8rnZt+OAD6NrVtNBFxEl0vyQiJdqRC0v3/DqAu7Ybdkke5eGO+bD4NjizFdb2Kf078mXZYO0jkBgH7r7QbiFUamh2VJKHUvxdKCLium699Z+d+po1g7NnYfhwozD6gw/mTEgBJCRAt24wb5458YqIiIjk6eJ6UuK6fIOM4t5lYUc+ux1+HQQH54Cbh3He1VuaHZXkQ0kpERGTXLxT3xdfGLOhLl3Gly27tMuwYVrKJyIiIi7i/DE4sc44VlLK9VW/PeeOfHu/MDceZ9n6Guz5D2CBf80A/3CzI5LLUFJKRMRkbm7wyCMQE3P5fnY7HDoEq1cXT1wiIiIil3XkR8AOVW4Bn0Czo5HCuHhHvg0D4Hgp21F11/vw+4Ul8S2j4bpu5sYjBSrymlJdCyh4cubMmaJ+SxGRUiG/WVKXWrsW2rXTjssiJZnul0SkVNDSvZLp4h35VnWBu34pHTvy7f0CNkUZx83GQd0nzY1HCqXIk1KVKlUq8Pm+ffsW9duKiJR4AQGF6/fyy/B//wf33gudO8Odd4K3t3NjE5GipfslESnxbOlwdLFxHNjZ3Fjkyljc4F9fQlwbOL3Z2JEv4iejIHpJdfh7WP+Ycdzg39BouLnxSKEVeVLqs88+K+ohRUTKhLZtjbpSCQn/1JC6VLkLm9ocPgzR0cbD1xciIowEVadO4OdXfDGLyNXR/ZKIlHjHV0HmOfD2g6ohZkcjV8rdN+eOfD/3hju+KZk78h1bBT89BHYb3NAPbnlHSwpKkBL4HSciUjpZrfDBB8bxpf+PWizG47//hVOnYOFCePppCAyElBT49lt4/HFjtlWrVjBuHGzbln9yS0REROSaZC/dq9WpZCYy5MKOfN8ZO/IlzIctL5sd0ZU7vRlWdgbbeQi8D1pOVUKqhNG/HiIiLqRrV5g710g2Xax2baO9a1djqd7dd8PHHxuFzzdtgjFjICTESEKtWwevvAJNm8INN8CQIRAXB+np5pyTiIiIlDJ2OyR8bxxr6V7JVj0Ubp9mHO94u2TtyJf8ByyPhIxkqNkOWs8CtyJfDCZOpqSUiIiL6doV9u+H5cthxgzj4759RvulLBa45RYYORJ+/fWfZX2dOhnJq/374aOPoGNHqF4dHnoIvvyy8EXVRURERHJJ3gV/7QU3T/APNzsauVbBvaDxK8ZxSdmRLzUBlkfA+WPG7o93fAfu5cyOSq6C0ogiIi7IaoWwsCt/XWAgPPWU8UhJgaVLYf58+OEHSEqCOXOMh5sbtG5t1KG67z6oX7/IT0FERERKq+yle37tS3ZxbPlH07FwdkfJ2JEv7ZQxQyrlAFS4CdovAs/LbyAirkszpURESilfXyPh9OmncOQIrF8Pr75qLOvLyoLVq+HFF6FBA6hXD/79b1ixAjIzzY5cREREXNqRC0kpLd0rPbJ35KvSHNKOG3WaMs6ZHVVumSmwohOc/R3K1YL2seBd0+yo5BqUiKTUlClTCA4Oxtvbm9DQUDZs2HDZ/mfOnGHQoEEEBATg5eVFvXr1WLhwoeN5m83Ga6+9Rp06dShXrhw33ngjr7/+OnZVBBaRUsrNDVq2hNdfhy1bjGV9kycby/o8POCPP2DiRGjfHmrWhN69YdYsOHPG7MhFRETEpaSdguM/Gce1OpkbixSt7B35vP3gzDb4uQ9k2cyO6h+2dFj9IJxcB55VjIRU+WCzo5Jr5PJJqdmzZxMVFcWoUaPYtGkTzZo1IzIykmPHjuXZPz09nYiICPbv38/cuXOJj49n6tSpBF5UNfjtt9/m448/ZvLkyezcuZO3336bCRMm8NFHHxXXaYmImOr662HQIFi82KgvNXcu9O0L1arB6dNGLauHH4YaNaBDB5g0Cf780+yoRURExHRHF4HdBpVuVkKgNHLVHfmybLC2LxxdDFYfCFsIlRubHZUUAZevKTVx4kQGDBhA//79AYiOjmbBggVMmzaN4cOH5+o/bdo0Tp06xc8//4yHhwcAwcHBOfr8/PPP3H///XTq1Mnx/MyZMwucgSUiUhpVqAAPPmg8bDZj97758+H772HnTli2zHg89xw0amTUoercGW6/3ah9JSIiImVIdj2pwHvNjUOcJ3tHvp97w84JUKkR3PCoefHY7bBxCBycDW4e0HYeVL/dvHikSLn0TKn09HQ2btxIePg/Ozq4ubkRHh7O2rVr83zN/PnzadWqFYMGDcLPz4+bb76ZcePGYbP9M+3wX//6F0uXLmX37t0AbNmyhTVr1nD33Xc794RERFyc1WoUQH/7bdixA/bsgfffN5b1Wa1G29tvQ5s24O8P/frB//4H5wooOWCzwcqVFlatCmTlSgs2F5oJLiIiIoWUlQFHfjSOVU+qdAvuBY1fNY43PPnPkk0zbBsNf/wfYIFWX0KtSPNikSLn0jOlTpw4gc1mw8/PL0e7n58fu3btyvM1e/fuZdmyZfTu3ZuFCxeyZ88ennnmGTIyMhg1ahQAw4cPJzk5mQYNGmC1WrHZbLz55pv07t0731jS0tJIS0tzfJ6cnAxARkYGGRkZ13qqOWSPV9TjStHQ9XFdujZF77rrjGV+gwYZ9aUWL7bwww9uLF5s4cQJC9Onw/Tp4OlpJyzMTqdOdjp1yuK66/4Z45tvLERFWUlIcAdaMHEiBAbamTjRxgMPqJafq9DPT+HpayQiZdbxnyHjDHhVg2qhZkcjztZ0DCTvhEP/g1UPQOSG4l+yGf8hbB9rHN82Ba7vUbzvL07n0kmpq5GVlUXNmjX55JNPsFqthISEkJCQwDvvvONISn399dd89dVXzJgxg8aNG7N582aGDRtGrVq1ePTRvKcljh8/njFjxuRqj42NxcfHxynnEhcX55RxpWjo+rguXRvnqVDBqDXVvbuFnTur8ssv/vzyiz9Hj5YnNtZCbCwMHWolOPgst92WiLd3Jl9+2SjXOAkJ0KOHlZde+oVWrY6acCaSH/38FCw1NdXsEEREzJG9617APeCmNfylnsUNWk2Hv/bC6d9g1X0Q8RN4VCie99/3FWwcahw3fR1uGlg87yvFyqWTUtWrV8dqtZKUlJSjPSkpCX9//zxfExAQgIeHB9aLCp00bNiQxMRE0tPT8fT05IUXXmD48OH07NkTgCZNmnDgwAHGjx+fb1JqxIgRREVFOT5PTk4mKCiIjh07UrFixWs91RwyMjKIi4sjIiLCURdLXIeuj+vStSle991nfLTbIT4+gx9+cGPBAgtr11rYv78S+/dXutDTDlguebUFi8XOV1/dxujRmapN5QL081N42bOlRUTKnITvjY+1tXSvzHD3NQqfL255YUe+3tD2G+cnJRMWwLp+xnH9odD4Fee+n5jGpZNSnp6ehISEsHTpUrp06QIYM6GWLl3K4MGD83xN69atmTFjBllZWbi5GSWzdu/eTUBAAJ6enoDxF87s57JZrVaysrLyjcXLywsvL69c7R4eHk67eXfm2HLtdH1cl65N8WvSxHiMGAEnTsCPP8Knn8KqVZA7IWWw2y0cPgzr1nkQFlac0crl6OenYPr6iEiZlPwHJMeDxR38O5odjRQn3yC441tY0s5ITG55GW5523nvd2wNrOkG9kwI7gO3TgRL3veTUvK5dKFzgKioKKZOncr06dPZuXMnAwcOJCUlxbEbX9++fRkxYoSj/8CBAzl16hRDhw5l9+7dLFiwgHHjxjFo0CBHn86dO/Pmm2+yYMEC9u/fzzfffMPEiRN54IEHiv38RERKm+rV4ZFH4OmnC9f/yBHnxiMiIiJF4MgC42PNO8Cz0uX7SulTPRRu/8w43jkB9n7unPc5vRVW3gu281Crk7ELoMXl0xZyDVx6phRAjx49OH78OCNHjiQxMZHmzZuzaNEiR/HzgwcP5pj1FBQUxOLFi3nuuedo2rQpgYGBDB06lJdeesnR56OPPuK1117jmWee4dixY9SqVYunnnqKkSNHFvv5iYiUVgEBhev3+uvg5gYPPgiagCIiIuKiEi7Uk9Kue2VX8MNwdgf8/gZseAoq3AQ1Whfd+Of+hOWRkHEWarSBNl+Dm24OSzuXT0oBDB48ON/leitWrMjV1qpVK9atW5fveBUqVGDSpElMmjSpiCIUEZFLtW0LtWsbRc3tl9lkb9cuo3h67drw7LMwYABUqVJ8cYqIiEgB0s/CsZXGceC95sYi5nLWjnx/H4XlHeF8IlRuCu2+B3fnbCgmrkXz4ERExCmsVvjgA+P40jIAFovxmDYNRo+GmjXh8GF46SUICoLBg+GPP4o9ZJESbcqUKQQHB+Pt7U1oaCgbNmzIt29YWBgWiyXXo1OnTo4+8+bNo2PHjlSrVg2LxcLmzZuL4SxExCUlxhr1fSrWhwp1zY5GzJS9I1+VWyDtOKzsDBnnrm3M9NPGDKm/9kL5G6H9YvCsXCThiutTUkpERJyma1eYOxcCA3O2165ttPfvD6NGwYEDRoKqSRNISYEpU6B+fWOHv+XLLz/TSkRg9uzZREVFMWrUKDZt2kSzZs2IjIzk2LFjefafN28eR48edTy2b9+O1Wqle/fujj4pKSm0adOGt992YjFbESkZspfu1dIsKcHYka/dfPD2h7Pb4adekGW7urEyU43E1pltxnh3xkI5/6KNV1yaklIiIuJUXbvC/v0QF5dJVNSvxMVlsm+f0Z7N29tIUG3ZAkuWQKdORiLq++/hzjvh1lth+nRISzPtNERc2sSJExkwYAD9+/enUaNGREdH4+Pjw7Rp0/LsX7VqVfz9/R2PuLg4fHx8ciSlHnnkEUaOHEl4eHhxnYaIuKIsGxxZaByrnpRk86kNd3wHVm848gNsGVHway6VlQFrusPxn8CjsjFDqvwNRR6quDYlpURExOmsVmjXzs4ddyTQrp0dqzXvfhYLdOgAP/xg1JoaOBDKlYPNm6FfPwgONgqjHz9ejMGLuLj09HQ2btyYI3nk5uZGeHg4a9euLdQYMTEx9OzZE19fX2eFKSIl1cn1kHbCSBrU+JfZ0Ygrqd4SQi/88WPnO1e2I589C9b2MxKe1nIQ9gNUaeqMKMXFlYhC5yIiUvbUrw//939GEmrqVPjoIzhyBEaOhHHjoE8fGDYMGjc2O1IRc504cQKbzebYmTibn58fu3btKvD1GzZsYPv27cTExFxzLGlpaaRdNKUxOTkZgIyMDDIyMq55/Itlj1fU40rR0PVxbVdyfdwOfYcVyPLviM0G2HRNnanE/ewEdsOt4XasO8dhX/8ktnLB2KsXsCOf3Y7b5uewHpiB3eKOrdUs7JVbQgk45xJ3fUxU2K+RklIiIuLSqlWD4cPh3/+GOXPg/ffh11/h00+NR8eO8NxzEBmZu6C6iBQsJiaGJk2a0LJly2sea/z48YwZMyZXe2xsLD4+ztlFKS4uzinjStHQ9XFthbk+7VNnURHYdCyQhIULnR+UACXsZ8fegtusrahlW4tt+f2sLPcOf7v55du9XvpsGmbMBGCj57Mk/GaH30rW91aJuj4mSU1NLVQ/JaVERKRE8PCAXr3g4Yfhp5+M5NS330JsrPFo1MiYOdWnj7HkT6SsqF69OlarlaSkpBztSUlJ+PtfvlhsSkoKs2bNYuzYsUUSy4gRI4iKinJ8npycTFBQEB07dqRixYpF8h7ZMjIyiIuLIyIiAg8PjyIdW66dro9rK/T1SdmPx8KD2HGj2V0v0cyzavEFWUaV2J+dzPbYl9+J15nfiPD4kMw7V4FHhVzd3PZ8jPU3IyFla/4+zW4aRLPijvUalNjrY4Ls2dIFUVJKRERKFIsF2rQxHnv3wocfQkwM7NgBTz4JL78MTz8NzzwDAQFmRyvifJ6enoSEhLB06VK6dOkCQFZWFkuXLmXw4MGXfe2cOXNIS0ujT58+RRKLl5cXXl5eudo9PDycdvPuzLHl2un6uLYCr8+xWAAsNVrj4Zv/zBcpeiXuZ8ejMoTNh8UtsST/jseGR6HN/+Dkz/D3USgXAKkJ8Nswo//No7A2GkY+ZUZdXom7PiYo7NdHhc5FRKTEuuEGmDQJDh+G996D66+HEyfgjTeM40cfNYqki5R2UVFRTJ06lenTp7Nz504GDhxISkoK/fv3B6Bv376MGJF7Z6SYmBi6dOlCtWrVcj136tQpNm/ezI4dOwCIj49n8+bNJCYmOvdkRMR1JPxgfNSue1IYPrWh7bf/7Mg3rxosbQ8/9zI+ru0D2KHeYGgyyuxoxUUoKSUiIiVepUoQFQV79hh1p/71L6NW5hdfwC23QPv2MH8+ZGWZHamIc/To0YN3332XkSNH0rx5czZv3syiRYscxc8PHjzI0aNHc7wmPj6eNWvW8Pjjj+c55vz587nlllvo1KkTAD179uSWW24hOjrauScjIq4h4y9IWmYcB95rbixSclRvCXUHGseZf+Xdp2Y7FQIVBy3fExGRUsPdHbp1Mx4bNhh1p+bMgRUrjEfdujB0KPTrB+XLmxysSBEbPHhwvsv1VqxYkautfv362O32fMfr168f/fr1K6Lo5LKybHB89T9LXGq0BbeSuqhFSo3EJZCVDuVvgIoNzI5GSoosGxyac5kOFtgUBbUf0L9zAmimlIiIlFItW8LMmbBvH7z4IlSubMykevZZCAoy2g4dMjtKESnzDs2D+cE5l7jMDzbaRcx05KKle5rVIoV1fDWkHr5MBzukHjL6iaCklIiIlHJBQfD220YCavJkY7bUmTPwzjtQpw707Anr15sdpYiUSYfmwepuuX+BS00w2pWYErPYsy6qJ6Wle3IF/j5acJ8r6SelnpJSIiJSJpQvD4MGQXy8UV+qfXuw2WD2bLj9dqMO1Zw5kJlpdqQiUiZk2WDjUCCvJZQX2jYOM/qJFLdTG+F8EriXhxp3mB2NlCTlCrn1cWH7SamnpJSIiJQpbm7QuTMsWwa//Wbs0OfhAWvXwkMPGTOp3nsPzp41O1IRKdUKu8Rlx1twbBWc2Wb0z/gLLlMLzCVk2bAcW0lg5iosx1YqsVYSZc+SCogEq6e5sUjJUqOtsQsf+S35tIBPkNFPBBU6FxGRMqx5c/j8c3jrLfi//4OPP4YDB+D552H0aHj8cRgyBG64IefrbDZYvRqOHoWAAGjbFqyq1SkiV6KwS1e2vpq7zeIOnpXBs4rx8Ljo2DOP44uf96jk3OLCh+bBxqG4px6mBcDKicYvqCEfQFBX572vFK2E742PgZ3NjUNKHjer8fO+uhtGYuriJPqFRFXIJBU5FwclpUREpMzz94exY2HECPjvf2HSJNixAz74AD78ELp0geeegzZt4JtvjB38Dl80waF2baNvV/2+JSKFVdilKxUbgt0GGWcg/TRkZYA9E9JOGI+r4VHxkmRV5cInuKze+Y+bXSPr0iWJ2TWy2s5VYqokSE2A078BFqh1t9nRSEkU1NX4ed84NOeMUJ/aRkJK/w7IRZSUEhERuaBcORgwAJ54AmJj4f33YfFiIxH1zTfGjKm9e3O/LiEBunWDuXOVmBKRQqoSAm7ekHU+nw4W4xe4e7b9M6PAbgdbKqSfMRJU6adzHmfk0X5xW2aKMU5GsvHgwJXH7eaVd9LKvSLs/y/518iyGDWyAu/XDAlXd2SB8bFaKHjXNDcWKbmCuho/78dXGzNDywUYS/b08y+XUFJKRETkEhYLREYajx07jJlTX3yRd0IKjN8TLRYYNgzuv19L+USkAOlnYOW9l09IQe4lLhYLuPsaD5/AK3/frIyLklhnCp/MSj9jfG7Pgqw0OJ9oPK7IRdvA+4VdeexSfLLrSdXW0j25Rm5W/bxLgZSUEhERuYxGjeCTT6BTJ2MZX37sdjh0yKg1FRZWXNGJSInzdxIsj4QzW4ylcg1fgD0fF88SFzcP8K5hPK6UPQsyzuWdwEo/DcfXwOFvCx5H28C7tsy/IXGJcVzrXnNjEZEyQUkpERGRQkhNLVy/J56A7t2hQwf417/Ax8e5cYlICfLXflgWAX/tAW8/aB8LVZpCo5dcf4mLxQ08KxkP3+tzP181pHBJKdvfRR6aFKGkZcY18gmCyk3MjkZEygAlpURERAohoJA1if/809jN7623wNMTWrWCO+80klS33Wa0iUgZdHYHLOsIfyeAbzDcGQcV6hrPlYYlLtnbwKcmkHddqQvWPwGnNkHTseBVtdjCk0LKXroX2NlYLioi4mRuZgcgIiJSErRta+yyl989usViJK4++wwefdTom54OK1fCqFHGzn1Vq8Ldd8M778DGjWCzFe85iIhJTv4CS+4wElKVGkHEmn8SUqVF9jbwgKMmloPFeFRrBdjhjynwQz344z+QpX8IXYbdDkeyk1JauicixUNJKRERkUKwWuGDC79vXZqYyv588mTo1w8+/xwOHoTduyE6Gh56CKpXh5QUWLQIXnwRWrSAGjWM3fomTzYKqtsvM7lAREqopOWw9E5IOwnVWkL4qqsrUl4SZG8Df+n5+dQ22iN/hjuXQqXGxtfjl6dhcQs4tsaceCWnM1uM2mZWH/Brb3Y0IlJGlIik1JQpUwgODsbb25vQ0FA2bNhw2f5nzpxh0KBBBAQE4OXlRb169Vi4cKHj+eDgYCwWS67HoEGDnH0qIiJSgnXtCnPnQuAlv2/Vrm20d72oJrHFAjfdBE89BbNnQ1ISbNkC778PnTtDxYpw+jR88w08+yw0bgy1akHv3hATA/v3F+upiYgzHP4Olt8NmX+BXwcjIeNVzeyonCuoK9y3n8x2cfzqFUVmuzi4b98/Rdv974S7N0PIR0ah99ObYUlb+Kn3haV/YprspXv+4WD1NjcWESkzXL6m1OzZs4mKiiI6OprQ0FAmTZpEZGQk8fHx1KxZM1f/9PR0IiIiqFmzJnPnziUwMJADBw5QuXJlR59ffvkF20VrJrZv305ERATdu3cvjlMSEZESrGtXuP9+Y5e9o0eNJXtt2xozqS7HzQ2aNjUew4ZBZqaxhG/ZMuOxZg0kJsKMGcYDoE4dox5V9sPf3+mnJyJFZe8XsP4xsNug9gPQeiZYvcyOqni4WbHXbEeCewrNarbLXbTdzR3qD4bre8DW12DPJ3BgBiR8B41fgQbPKSlihoTvjY+Bnc2NQ0TKFJdPSk2cOJEBAwbQv39/AKKjo1mwYAHTpk1j+PDhufpPmzaNU6dO8fPPP+Ph4QEYM6MuVqNGzm1w33rrLW688UbatWvnnJMQEZFSxWqFsLBrG8PdHUJDjceIEXD+PKxb90+Sav162LfPmDUVE2O8plGjfxJU7doZNapExAXt+gA2DTOOb+gHLacaiRjJybsGtIyGuk/CxiFw/CfY8jL8GQO3vm/UNVKx7eLxdxKcvLAapdY95sYiImWKSy/fS09PZ+PGjYSHhzva3NzcCA8PZ+3atXm+Zv78+bRq1YpBgwbh5+fHzTffzLhx43LMjLr0Pf773//y2GOPYdF/eiIiYhJvbyPRNXasMWvq1ClYuBCefx5uvdX4vWzHDqP+VNeuRo2qFi2M+lSLFsFff5l9BiKC3Q5bR/2TkGoQBaExSkgVpOqtEL4a/vUVlKsFf/0Jq+6DFfdAcrzZ0ZUNRy6UOqkaAj61zI1FRMoUl/4f8sSJE9hsNvz8/HK0+/n5sWvXrjxfs3fvXpYtW0bv3r1ZuHAhe/bs4ZlnniEjI4NRo0bl6v/tt99y5swZ+vXrd9lY0tLSSEtLc3yenJwMQEZGBhkZGVd4ZpeXPV5RjytFQ9fHdenauDZdnyvj7Q3h4cYDjCTVypUWVqywsHy5G7t2Wdi40VgC+M474O5uJzTUTliYnfbtjWOvQq4UstlgxQobq1YF4uVlIyys4OWIZZm+hyVP9izYOAx2f2R83vQNaPyyZvoUlsUCwb0g8D74fRzseg+OLoIFN0ODYXDza+BR0ewoSy8t3RMRk7h0UupqZGVlUbNmTT755BOsVishISEkJCTwzjvv5JmUiomJ4e6776ZWrcv/RWD8+PGMGTMmV3tsbCw+Pj5FFv/F4uLinDKuFA1dH9ela+PadH2unpcXREYaj1OnvNi2rQZbt1Zn69YaHD/uw08/WfjpJ3jzTfD0zKRhw1M0bXqCJk2Oc+ONZ7Fac2/vt3ZtAJ9+2oSTJ8sBLZg4EapV+5snnthGq1ZHi/8kS4DU1FSzQxBXk5UB6x6D/f8FLNBiMtR7xuyoSiaP8tB8HNz4GGyKMpIlO9+FfV9C87ehziNgcenFHiWPLQ0SY43jwHvNjUVEyhyXTkpVr14dq9VKUlJSjvakpCT886n2GhAQgIeHB9aL/sTbsGFDEhMTSU9Px9PT09F+4MABlixZwrx58wqMZcSIEURFRTk+T05OJigoiI4dO1KxYtH+1SYjI4O4uDgiIiIcdbHEdej6uC5dG9em6+Nce/dmOGZRrVhhISnJnS1barJli7EpSKVKdtq2NWZRhYVl0bgxfPedhQkTrNgvyVWdOuXNhAm3MWuWjQceyJ3IKuuyZ0uLAJD5N/zUw0ieWNyh1XRjxo9cmwp1od18OPKjMQPt3G5Y1w/++BhafATVbjM7wtLj2ErITIFyAVDlFrOjEZEyxqWTUp6enoSEhLB06VK6dOkCGDOhli5dyuDBg/N8TevWrZkxYwZZWVm4uRl/Rdm9ezcBAQE5ElIAn332GTVr1qRTp04FxuLl5YVXHusgPDw8nPbLlTPHlmun6+O6dG1cm66Pc9Svbzyeesooa7Njxz9F01esgDNnLPzwg4UffgCwUr06pKSQKyEFYLdbsFjg+efdefBBLeW7lL5/xSEjGVbeZ/xSb/WGNnMhsOD7SrkCte4Gvw6w+0PYNgZOrofFLeGG/tBsPJTzK3gMubyEH4yPte7VLDQRKXYu/69OVFQUU6dOZfr06ezcuZOBAweSkpLi2I2vb9++jBgxwtF/4MCBnDp1iqFDh7J7924WLFjAuHHjGDRoUI5xs7Ky+Oyzz3j00Udxd3fp3JyIiMgVsVigcWN49ln45hs4cQJ+/RXefttY+ufjY7T9/Xf+Y9jtcOgQrF5dfHGLlCjnj8OS9kZCyqMitI9VQspZrJ7Q8HnovBvqPGq07f0MfqgHOycayyfl6tjtF9WT0tI9ESl+Lp+N6dGjB8ePH2fkyJEkJibSvHlzFi1a5Ch+fvDgQceMKICgoCAWL17Mc889R9OmTQkMDGTo0KG89NJLOcZdsmQJBw8e5LHHHivW8xERESluViuEhBiPF1+E9HQYNw7yKJWYy1GVlRLJLeUQLI8wdobzqgHtF0NVLXtyunIB0OpzuOlp+PVZOPUr/PZv+HMqhHwAAR3NjrDkSd4BKfvBzQv8O5gdjYiUQS6flAIYPHhwvsv1VqxYkautVatWrFu37rJjduzYEXteaxZERERKOU9PCAsrXFIqIMDp4YiULMm7YVk4pB4CnyC4cwlUrGd2VGVL9dshcj3s/Rw2D4fkXbA8EmrfD7dOhPI3mB1hieF2dKFx4N8B3H3NDUZEyiSXX74nIiIiRa9tW6hdu+Dd6ufOhdOniycmEZd3ahPEtTESUhXrQ8RPSkiZxeJm7NDXeTfUf84oMn/4O/ihEWx51SjcLQWyHFlgHGjpnoiYREkpERGRMshqhQ8+MI4vTUxd/PmUKXDTTfCf/4DNVnzxyZWbMmUKwcHBeHt7ExoayoYNG/LtGxYWhsViyfW4ePMXu93OyJEjCQgIoFy5coSHh/PHH38Ux6m4pmOrYGl7SDsOVW6F8NXgG2R2VOJZGUImwj1bwD8cstLg9zfhhwawf1beuzkIAJ72ZCwnL6wuqaV6aCJiDiWlREREyqiuXY2ZUIGBOdtr14b//Q+WLjUKpp88CU8/DS1awJo15sQqlzd79myioqIYNWoUmzZtolmzZkRGRnLs2LE8+8+bN4+jR486Htu3b8dqtdK9e3dHnwkTJvDhhx8SHR3N+vXr8fX1JTIykvPnzxfXabmOhAXG8rCMZKjZDsKXg3cNs6OSi1VqZBSbb/sN+AZD6mH4+WFY0g5ObzE7OpdU07YJC1lQuSn4Xmd2OCJSRikpJSIiUoZ17Qr790NcXCZRUb8SF5fJvn1G+513wubN8OGHULmycdy2LfTuDQkJ5sYtOU2cOJEBAwbQv39/GjVqRHR0ND4+PkybNi3P/lWrVsXf39/xiIuLw8fHx5GUstvtTJo0iVdffZX777+fpk2b8sUXX3DkyBG+/fbbYjwzF7B/JqzqArbzENgZwn40dtsT12OxQFAX6LQDmr4O1nJwfDUsuhV+eQbSTpodoUvxz/zFOAjsbG4gIlKmlYhC5yIiIuI8Viu0a2cnJSWBdu2aYbX+85y7Ozz7LPTsCa++ClOnwowZ8N138PLLEBUF3t7mxS6Qnp7Oxo0bGTFihKPNzc2N8PBw1q5dW6gxYmJi6NmzJ76+RqHjffv2kZiYSHh4uKNPpUqVCA0NZe3atfTs2TPPcdLS0khLS3N8npycDEBGRgYZGRlXfG6Xkz1eUY97Mbc90bj9NhQLdrKu64XttqlgdwcnvmdpURzXJ3/uUP8lCOqFdetw3A7NgT8+xr5/Flk3jyHrhifArWz/GpSRlkpN228AZPrdhV3f0y7D3J8dKYiuT+EV9mtUtv81FhERkUKpUcOoK/XUUzBkCPz0E7zyCsTEwPvvQ+fOBRdNF+c4ceIENpsNPz+/HO1+fn7s2rWrwNdv2LCB7du3ExMT42hLTEx0jHHpmNnP5WX8+PGMyWNbx9jYWHx8fAqM5WrExcUV/aB2O/Uy5tAwYwYAe907se1EN1jkhPcq5Zxyfa5Ib6p5N6NJ+qdUytiP9bch/LVlIts8n+Ck9WaTYzOJ3cYNGQtoQirp+PLj2qPgttDsqOQS5v/syOXo+hQsNTW1UP2UlBIREZFCu/VWWL0aZs6EF16AvXvh/vshMhImTYIGDcyOUK5UTEwMTZo0oWXLltc81ogRI4iKinJ8npycTFBQEB07dqRixaJd8paRkUFcXBwRERF4eHgU3cB2O25bX8K620hI2Rq9SlCj1whS1vWKOO36XJV7ICsK295Pcds+ikoZ+2lz/lWygrpja/oW+JSdgvWWw99g3RyFJcNYg+1JCvfxHLamE7HXfsDk6ARc7WdHLqXrU3jZs6ULoqSUiIiIXBGLBXr1gvvug3Hj4L33YPFiaNLEmEU1ciRUqmR2lGVH9erVsVqtJCUl5WhPSkrC39//sq9NSUlh1qxZjB07Nkd79uuSkpIICAjIMWbz5s3zHc/LywsvL69c7R4eHk67eS/SsbMyYcNTsPcz4/NbJ2FtMBTr5V8ll+HMa39lPKDhs3BDL9g6EvZE43ZoDm5HfoDGL0PD58FaytciH5oHa3sCOXcktPx9BPe1PaHtXAjqak5skovr/OxIXnR9ClbYr48KnYuIiMhVKV/eSEr9/ruxfC8zEyZOhHr14LPPICvL7AjLBk9PT0JCQli6dKmjLSsri6VLl9KqVavLvnbOnDmkpaXRp0+fHO116tTB398/x5jJycmsX7++wDFLLNt5WPOQkZCyWOH2z6HBULOjkqLmVQ1umwJ3bYKad4Dtb9j6GvzQCA59C3Z7gUOUSFk22DiUSxNShgttG4cZ/UREipFmSomIiMg1qVsX5s+HH3+EYcNg92547DGIjjZ27gsNNTvC0i8qKopHH32UFi1a0LJlSyZNmkRKSgr9+/cHoG/fvgQGBjJ+/Pgcr4uJiaFLly5Uq1YtR7vFYmHYsGG88cYb3HTTTdSpU4fXXnuNWrVq0aVLl+I6reKTcQ5WPQBJS8HNC9rMhtr3mx2VOFOVZtBhBRz8Gn57HlL2weoHwD8CQj6ASg3/6ZtlM3bx+/solAuAGm3BzUXmz2WmQtpxOH8858fs4/PHjOOUg3D+6GUGskPqIeM8/cKKK3oRESWlREREpGjcfTd06AAffQRjxsCGDXD77dCvH4wfDwWsJJNr0KNHD44fP87IkSNJTEykefPmLFq0yFGo/ODBg7i55ZwgHx8fz5o1a4iNjc1zzBdffJGUlBSefPJJzpw5Q5s2bVi0aBHepW27xbSTsOIeOLkB3MtDu/ng197sqKQ4WCxwfQ8IvBd+fwt2vgOJcbCwKdR7FpqMMhKVG4dC6uF/XudT20hcFfVSN7sdMv/KI8l0LP+kk61whYQL7e/LJa5ERIqeklIiIiJSZDw94d//ht69YcQI+Pxz4/G//8GoUfDss0YfKXqDBw9m8ODBeT63YsWKXG3169fHfpmlShaLhbFjx+aqN1WqpB6B5R3h7O/Gsq6wH6HabWZHJcXN3ReavQ439odN/4bD30L8+7A3BjLyKNSbmgCruxVcg8luh4yz/8xWujShlFdbVtqVx+/mCV41wLuG8fHi4+yPKYdh05CCxyoXUHAfEZEipKSUiIiIFDl/f6Ou1NNPG4moX36B55+HqVONXfruusvsCKXMO7cHlkVAyn4oFwh3xkKlRmZHJWYqfwPc8Q0cjYVfh8C5+Hw6Xkjmrn8S/k40ZttdmmxKOw5pJyAr48rjsJbLO8nkXTPvpJN7BWPW1+Vk2WDXBCOhlmddKYsxA6xG2yuPV0TkGigpJSIiIk4TGgrr1sH06TB8OMTHG8v8Onc2iqLXrWt2hFImnd5qzJA6nwTl68KdcVA+2OyoxFUEdIQWk2F5xOX7pZ+EXwcVPJ57hcvPYsqVZPItmvO4mJvVWHK4uhtgIWdi6kJCK2SS69TKEpEyQ0kpERERcSo3N+jfH7p2hddfhw8+gO+/h8WLjaV+L79s7OQnUiyO/wwrOkHGGajcDNovhnJ+ZkclribteOH6VQ2BKrfkkWSqeeHz6mB1kTpsQV2NJYd51siaVPQ1skRECkFJKRERESkWlSrBu+/CE08Yu/QtXmwUQJ8+HSZMgF69Cl6BInJNjiyG1V2N4tA1WkO7H8CzstlRiSsqbG2lW94tWbvVBXWFwPvJPLqczet+pPntd+Me0F4zpETENG4FdxEREREpOg0awI8/wvz5cMMNcOQI9OkDbdvCpk1mRyel1sE5sKqzkZAKuAvaxyohJfmr0daYQUR+mXIL+ASVzBpMblbsNduR4H4H9prtlJASEVMpKSUiIiLFzmIx6kr9/juMGwc+PvDTT9CiBTz1FBwv5MoZkULZMxXW9DCKTl/XA+74Dtx9zI5KXFl2DSYgd2JKNZhERIqKklIiIiJiGm9vGDHCKIDeq5exg/onn0C9evDRR5CZaXaEUuLtmAAbngTsUPcp+NdXYPU0OyopCbJrMPkE5mz3qW20qwaTiMg1U1JKRERETFe7Nnz1FaxeDc2bw5kzMGSIcbxsmcnBSclkt8Pm4bD5JePzRiPgto81s0WuTFBXuG8/dFgO/5phfLxvnxJSIiJFREkpERERcRlt2sCvv0J0NFSrZizv69ABunWD/fvNjk5KjCwb/PI07Hjb+Lz5BGg+TpX05eq4WY1i5sEPGx+V2BQRKTJKSomIiIhLsVqNulK7d8Ozzxqf/+9/0LAhjB4NqalmRyguzZYOP/eCPZ+AxQ1aToVGL5gdlYiIiORBSSkRERFxSVWrwocfwm+/Qfv2cP48jBljJKfmzjVWZ4nkkJkCq+6Dg1+Dmwe0ng11nzA7KhEREcmHklIiIiLi0po0gaVLYc4cuO46OHgQunc3lvVt22Z2dOIy0k/Dso5wdDFYfaDdArium9lRiYiIyGWUiKTUlClTCA4Oxtvbm9DQUDZs2HDZ/mfOnGHQoEEEBATg5eVFvXr1WLhwYY4+CQkJ9OnTh2rVqlGuXDmaNGnCr7/+6szTEBERkatksRh1pXbuhFGjjF37li+HW24xlvidOvVPX5sNVqyAmTONjzabWVGL02TZsBxbSWDmKizHVkJqAiwJgxM/g0dluHMJBESYHaWIiIgUwN3sAAoye/ZsoqKiiI6OJjQ0lEmTJhEZGUl8fDw1a9bM1T89PZ2IiAhq1qzJ3LlzCQwM5MCBA1SuXNnR5/Tp07Ru3Zr27dvz448/UqNGDf744w+qVKlSjGcmIiIiV8rHx6gr1b8/PP+8sYxv8mQjAfXmm0Zx9Oeeg8OH/3lN7drwwQfQVZtllQ6H5sHGobinHqYFwMqJYLGC3Qbe/nBnLFRuYnaUIiIiUggun5SaOHEiAwYMoH///gBER0ezYMECpk2bxvDhw3P1nzZtGqdOneLnn3/Gw8MDgODg4Bx93n77bYKCgvjss88cbXXq1HHeSYiIiEiRuv56YznfsmUwZIixS9/TT+fdNyHBmGU1d64SUyXeoXmwuhtwSUEx+4XpcDe/poSUiIhICeLSy/fS09PZuHEj4eHhjjY3NzfCw8NZu3Ztnq+ZP38+rVq1YtCgQfj5+XHzzTczbtw4bBfN3Z8/fz4tWrSge/fu1KxZk1tuuYWpU6c6/XxERESkaN15J2zebMyEsljy7pNdEH3YMC3lK9GybLBxKLkSUg4W2PGW0U9ERERKBJeeKXXixAlsNht+fn452v38/Ni1a1eer9m7dy/Lli2jd+/eLFy4kD179vDMM8+QkZHBqFGjHH0+/vhjoqKiePnll/nll18YMmQInp6ePProo3mOm5aWRlpamuPz5ORkADIyMsjIyCiK03XIHq+ox5WioevjunRtXJuuj2sr6denUSMLdnv+tzV2Oxw6BMuXZ9Ku3bVt21dSv0Yl3vHVkHr4Mh3skHrI6OcXVlxRiYiIyDVw6aTU1cjKyqJmzZp88sknWK1WQkJCSEhI4J133nEkpbKysmjRogXjxo0D4JZbbmH79u1ER0fnm5QaP348Y8aMydUeGxuLj4+PU84lLi7OKeNK0dD1cV26Nq5N18e1ldTrs2pVIBgVhi7rxx83k5KScE3vlZqaek2vl6v099Gi7SciIiKmc+mkVPXq1bFarSQlJeVoT0pKwt/fP8/XBAQE4OHhgdVqdbQ1bNiQxMRE0tPT8fT0JCAggEaNGuV4XcOGDfnf//6XbywjRowgKirK8fn/s3ffYVEdXwPHv7v0DioICogVsaJi7yX2FsXee4r9Z6KmWN9oYowlmmhMomhiN7ZYgy0SuyKKitjFgr0AIgi79/2DsHEFFBTYBc7neXh079479+ydZZmdO3MmKioKDw8PmjZtir29/du8vDQlJCQQGBjIe++9p8uLJYyH1I/xkroxblI/xi2n14+NjYpZs968X4sWvtSvX/GdzpU8WlpkMyu3zN1PCCGEEAZn1J1S5ubmVKlShd27d9O+fXsgaZTT7t27GTp0aKrH1K5dmxUrVqDValGrk1JmXbhwATc3N8zNzXX7hIeH6x134cIFihQpkmYsFhYWWFhYpNhuZmaWZY33rCxbvDupH+MldWPcpH6MW06tn4YNk1bZu3XrvxxSL1Opkp5v2NCUl+5bvZWceH1yBee6YO0OsbdIPa+UKul557rZHZkQQggh3pJRJzoHGD16ND///DNLly4lLCyMDz/8kGfPnulW4+vduzfjx4/X7f/hhx/y6NEjRowYwYULF9i6dSvTpk3j448/1u0zatQoDh8+zLRp07h06RIrVqxg0aJFevsIIYQQIucwMUlKdg4pE54nP54zh3fukBIGpDaBKv9WMq9mtf/3cZU5SfsJIYQQIkcw+k6pLl26MHPmTCZMmICvry8hISHs2LFDl/w8IiKCyMj/cgd4eHiwc+dOjh07RoUKFRg+fDgjRoxg3Lhxun2qVq3Khg0bWLlyJeXKlWPq1KnMmTOHHj16ZPvrE0IIIUTm6NAB1q2DwoX1t7u7J23v0MEwcYlM5NEB6q4D61cq2do9abuHVLIQQgiRkxj19L1kQ4cOTXO63r59+1Jsq1mzJocPH35tma1bt6Z169aZEZ4QQgghjESHDtCuHQQFQWQkuLlB3boyQipX8egAhduRGLmXkMPb8a3RAlO3hjJCSgghhMiBckSnlBBCCCFEepmYQIMGho5CZCm1CYpLfW6ZPqOiS33pkBJCCCFyKKOfvieEEEIIIYQQQgghch8ZKfWWlH+X9smKZaETEhKIjY0lKipKVvgxQlI/xkvqxrhJ/Rg3qZ/0S/7br6S2zJ/QI+2lvEvqx7hJ/RgvqRvjJvWTfultL0mn1FuKjo4GkhKrCyGEECLviY6OxsHBwdBhGDVpLwkhhBB525vaSypFbvO9Fa1Wy+3bt7Gzs0P16trT7ygqKgoPDw9u3LiBvb19ppYt3p3Uj/GSujFuUj/GTeon/RRFITo6mkKFCqFWSyaE15H2Ut4l9WPcpH6Ml9SNcZP6Sb/0tpdkpNRbUqvVuLu7Z+k57O3t5Y1uxKR+jJfUjXGT+jFuUj/pIyOk0kfaS0Lqx7hJ/RgvqRvjJvWTPulpL8ntPSGEEEIIIYQQQgiR7aRTSgghhBBCCCGEEEJkO+mUMkIWFhZMnDgRCwsLQ4ciUiH1Y7ykboyb1I9xk/oROY28Z42b1I9xk/oxXlI3xk3qJ/NJonMhhBBCCCGEEEIIke1kpJQQQgghhBBCCCGEyHbSKSWEEEIIIYQQQgghsp10SgkhhBBCCCGEEEKIbCedUkIIIYQQQgghhBAi20mnlBH64Ycf8PLywtLSkurVq3P06FFDh5TnTZ8+napVq2JnZ4eLiwvt27cnPDzc0GGJNHz99deoVCpGjhxp6FDEv27dukXPnj3Jnz8/VlZWlC9fnuPHjxs6rDxPo9Hw5ZdfUrRoUaysrChevDhTp05F1kAROYG0l4yTtJlyDmkvGR9pLxknaS9lLemUMjKrV69m9OjRTJw4keDgYCpWrEizZs24d++eoUPL0/7++28+/vhjDh8+TGBgIAkJCTRt2pRnz54ZOjTximPHjvHTTz9RoUIFQ4ci/vX48WNq166NmZkZ27dv59y5c3z33Xc4OTkZOrQ875tvvmHBggXMnz+fsLAwvvnmG2bMmMG8efMMHZoQryXtJeMlbaacQdpLxkfaS8ZL2ktZS6VI955RqV69OlWrVmX+/PkAaLVaPDw8GDZsGOPGjTNwdCLZ/fv3cXFx4e+//6ZevXqGDkf8KyYmhsqVK/Pjjz/yf//3f/j6+jJnzhxDh5XnjRs3jgMHDhAUFGToUMQrWrduTcGCBfn111912zp27IiVlRW///67ASMT4vWkvZRzSJvJ+Eh7yThJe8l4SXspa8lIKSPy4sULTpw4QZMmTXTb1Go1TZo04dChQwaMTLzq6dOnAOTLl8/AkYiXffzxx7Rq1Urvd0gY3ubNm/Hz86NTp064uLhQqVIlfv75Z0OHJYBatWqxe/duLly4AMCpU6f4559/aNGihYEjEyJt0l7KWaTNZHykvWScpL1kvKS9lLVMDR2A+M+DBw/QaDQULFhQb3vBggU5f/68gaISr9JqtYwcOZLatWtTrlw5Q4cj/rVq1SqCg4M5duyYoUMRr7hy5QoLFixg9OjRfPbZZxw7dozhw4djbm5Onz59DB1enjZu3DiioqIoXbo0JiYmaDQavvrqK3r06GHo0IRIk7SXcg5pMxkfaS8ZL2kvGS9pL2Ut6ZQSIoM+/vhjzpw5wz///GPoUMS/bty4wYgRIwgMDMTS0tLQ4YhXaLVa/Pz8mDZtGgCVKlXizJkzLFy4UBpZBrZmzRqWL1/OihUrKFu2LCEhIYwcOZJChQpJ3Qgh3pm0mYyLtJeMm7SXjJe0l7KWdEoZkQIFCmBiYsLdu3f1tt+9exdXV1cDRSVeNnToULZs2cL+/ftxd3c3dDjiXydOnODevXtUrlxZt02j0bB//37mz59PfHw8JiYmBowwb3Nzc6NMmTJ623x8fPjjjz8MFJFI9sknnzBu3Di6du0KQPny5bl+/TrTp0+XRpYwWtJeyhmkzWR8pL1k3KS9ZLykvZS1JKeUETE3N6dKlSrs3r1bt02r1bJ7925q1qxpwMiEoigMHTqUDRs2sGfPHooWLWrokMRLGjduTGhoKCEhIbofPz8/evToQUhIiDSwDKx27doplgO/cOECRYoUMVBEIllsbCxqtX5TwMTEBK1Wa6CIhHgzaS8ZN2kzGS9pLxk3aS8ZL2kvZS0ZKWVkRo8eTZ8+ffDz86NatWrMmTOHZ8+e0a9fP0OHlqd9/PHHrFixgk2bNmFnZ8edO3cAcHBwwMrKysDRCTs7uxS5KmxsbMifP7/ksDACo0aNolatWkybNo3OnTtz9OhRFi1axKJFiwwdWp7Xpk0bvvrqKzw9PSlbtiwnT55k1qxZ9O/f39ChCfFa0l4yXtJmMl7SXjJu0l4yXtJeyloqRVEUQwch9M2fP59vv/2WO3fu4Ovry/fff0/16tUNHVaeplKpUt2+ZMkS+vbtm73BiHRp0KCBLHFsRLZs2cL48eO5ePEiRYsWZfTo0QwaNMjQYeV50dHRfPnll2zYsIF79+5RqFAhunXrxoQJEzA3Nzd0eEK8lrSXjJO0mXIWaS8ZF2kvGSdpL2Ut6ZQSQgghhBBCCCGEENlOckoJIYQQQgghhBBCiGwnnVJCCCGEEEIIIYQQIttJp5QQQgghhBBCCCGEyHbSKSWEEEIIIYQQQgghsp10SgkhhBBCCCGEEEKIbCedUkIIIYQQQgghhBAi20mnlBBCCCGEEEIIIYTIdtIpJYQQQgghhBBCCCGynXRKCSFEFlKpVGzcuNHQYQghhBBCGC1pLwmRd0mnlBAi1+rbty8qlSrFT/PmzQ0dmhBCCCGEUZD2khDCkEwNHYAQQmSl5s2bs2TJEr1tFhYWBopGCCGEEML4SHtJCGEoMlJKCJGrWVhY4Orqqvfj5OQEJA0VX7BgAS1atMDKyopixYqxbt06veNDQ0Np1KgRVlZW5M+fn8GDBxMTE6O3z+LFiylbtiwWFha4ubkxdOhQvecfPHjA+++/j7W1NSVLlmTz5s265x4/fkyPHj1wdnbGysqKkiVLpmgUCiGEEEJkJWkvCSEMRTqlhBB52pdffknHjh05deoUPXr0oGvXroSFhQHw7NkzmjVrhpOTE8eOHWPt2rXs2rVLrxG1YMECPv74YwYPHkxoaCibN2+mRIkSeueYPHkynTt35vTp07Rs2ZIePXrw6NEj3fnPnTvH9u3bCQsLY8GCBRQoUCD7LoAQQgghxBtIe0kIkWUUIYTIpfr06aOYmJgoNjY2ej9fffWVoiiKAigffPCB3jHVq1dXPvzwQ0VRFGXRokWKk5OTEhMTo3t+69atilqtVu7cuaMoiqIUKlRI+fzzz9OMAVC++OIL3eOYmBgFULZv364oiqK0adNG6devX+a8YCGEEEKIDJL2khDCkCSnlBAiV2vYsCELFizQ25YvXz7d/2vWrKn3XM2aNQkJCQEgLCyMihUrYmNjo3u+du3aaLVawsPDUalU3L59m8aNG782hgoVKuj+b2Njg729Pffu3QPgww8/pGPHjgQHB9O0aVPat29PrVq13uq1CiGEEEK8DWkvCSEMRTqlhBC5mo2NTYrh4ZnFysoqXfuZmZnpPVapVGi1WgBatGjB9evX2bZtG4GBgTRu3JiPP/6YmTNnZnq8QgghhBCpkfaSEMJQJKeUECJPO3z4cIrHPj4+APj4+HDq1CmePXume/7AgQOo1Wq8vb2xs7PDy8uL3bt3v1MMzs7O9OnTh99//505c+awaNGidypPCCGEECIzSXtJCJFVZKSUECJXi4+P586dO3rbTE1Ndckx165di5+fH3Xq1GH58uUcPXqUX3/9FYAePXowceJE+vTpw6RJk7h//z7Dhg2jV69eFCxYEIBJkybxwQcf4OLiQosWLYiOjubAgQMMGzYsXfFNmDCBKlWqULZsWeLj49myZYuukSeEEEIIkR2kvSSEMBTplBJC5Go7duzAzc1Nb5u3tzfnz58HklZ6WbVqFR999BFubm6sXLmSMmXKAGBtbc3OnTsZMWIEVatWxdramo4dOzJr1ixdWX369CEuLo7Zs2czZswYChQogL+/f7rjMzc3Z/z48Vy7dg0rKyvq1q3LqlWrMuGVCyGEEEKkj7SXhBCGolIURTF0EEIIYQgqlYoNGzbQvn17Q4cihBBCCGGUpL0khMhKklNKCCGEEEIIIYQQQmQ76ZQSQgghhBBCCCGEENlOpu8JIYQQQgghhBBCiGwnI6WEEEIIIYQQQgghRLaTTikhhBBCCCGEEEIIke2kU0oIIYQQQgghhBBCZDvplBJCCCGEEEIIIYQQ2U46pYQQQgghhBBCCCFEtpNOKSGEEEIIIYQQQgiR7aRTSgghhBBCCCGEEEJkO+mUEkIIIYQQQgghhBDZTjqlhBBCCCGEEEIIIUS2k04pIYQQQgghhBBCCJHtpFNKCCGEEEIIIYQQQmQ76ZQSQgghhBBCCCGEENlOOqWEEEIIIYQQQgghRLaTTikhhNHat28fKpWKffv26bb17dsXLy+vNx577do1VCoVAQEBmRqTl5cXffv2zdQyhRBCCJFzSPvEeKW3Hl6WWn2KzPUuvzMi95NOKSFygICAAFQqle7H1NSUwoUL07dvX27dupVi/wYNGqBSqWjTpk2K55IbQzNnztRtS/5DoVKpOHHiRIpj+vbti62t7WtjrFChAp6eniiKkuY+tWvXpmDBgiQmJr62LEM7ePAgkyZN4smTJ4YOJVU//vgjKpWK6tWrGzoUIYQQeZi0T7KXMbZPXn0PWFpaUqpUKYYOHcrdu3cNHV6OEBcXx/jx4/Hy8sLa2prSpUszZsyYDJXRt29fvXqwsLCgVKlSTJgwgbi4uCyKXIjMIZ1SQuQgU6ZM4bfffmPhwoW0aNGC33//nfr166f5x2bLli2pNuJeZ9KkSW8VW48ePbhx4wZBQUGpPn/t2jUOHTpEly5dMDU1fatzAPz888+Eh4e/9fHpcfDgQSZPnpxqoy88PJyff/45S8//JsuXL8fLy4ujR49y6dIlg8YihBBCSPtE2ifJ74H58+dTq1YtFixYQM2aNYmNjc3WON6mHurVq8fz58+pV69eFkX1emPHjuXrr7+mcePGzJkzh1atWvH7779nuBwLCwt+++03fvvtN2bNmoWXlxdTp05lwIABWRC1EJlHOqWEyEFatGhBz549GThwIL/88gtjxozh8uXLbN68OcW+np6eODk5MXny5HSX7+vry5YtWwgODs5wbN27d0elUrFixYpUn1+5ciWKotCjR48Ml/0yMzMzLCws3qmMd2FhYYGZmZnBzn/16lUOHjzIrFmzcHZ2Zvny5QaL5U2ePXtm6BCEEEJkA2mfSPvk5fdAQEAAI0eO5OrVq2zatCnNY7KinfA29aBWq7G0tEStNsxX41WrVtGyZUt+/fVXBg8ezHfffcf169czXI6pqSk9e/akZ8+efPzxx+zcuZMaNWqwcuVKGbUmjJp0SgmRg9WtWxeAy5cvp3jOzs6OUaNG8eeff6a7ETds2DCcnJze6m6kh4cH9erVY926dSQkJKR4fsWKFRQvXpzq1atz/fp1PvroI7y9vbGysiJ//vx06tSJa9euvfE8qc0/f/LkCX379sXBwQFHR0f69OmT6l3E06dP07dvX4oVK4alpSWurq7079+fhw8f6vaZNGkSn3zyCQBFixbVDYNOji21nA1XrlyhU6dO5MuXD2tra2rUqMHWrVv19kmegrBmzRq++uor3N3dsbS0pHHjxhka7bR8+XKcnJxo1aoV/v7+aXZKPXnyhFGjRuHl5YWFhQXu7u707t2bBw8e6PaJi4tj0qRJlCpVCktLS9zc3OjQoYPu/ZRWjoXU8mEkT6G4fPkyLVu2xM7OTtfADwoKolOnTnh6emJhYYGHhwejRo3i+fPnKeI+f/48nTt3xtnZGSsrK7y9vfn8888B2Lt3LyqVig0bNqQ4bsWKFahUKg4dOpTuaymEECJrSPskSV5qn7yqUaNGQNLNtOTrk1Y7QavVMmfOHMqWLYulpSUFCxZkyJAhPH78OEW527dvp379+tjZ2WFvb0/VqlX1OhxTq4dVq1ZRpUoV3THly5dn7ty5Ka7Bq+2dtWvXUqVKFaysrChQoAA9e/ZMMS01+XXdunWL9u3bY2tri7OzM2PGjEGj0aTrWqnV6hTTSzOjg1OlUlGnTh0UReHKlSt6z23fvp26detiY2ODnZ0drVq14uzZsynKeF27DHin3xkhkkmnlBA5WPIHvpOTU6rPjxgxIkONOHt7+ww3FF/Wo0cPHj58yM6dO/W2h4aGcubMGV3j49ixYxw8eJCuXbvy/fff88EHH7B7924aNGiQ4WHeiqLQrl07fvvtN3r27Mn//d//cfPmTfr06ZNi38DAQK5cuUK/fv2YN28eXbt21d2dSm4MdOjQgW7dugEwe/Zs3TBoZ2fnVM9/9+5datWqxc6dO/noo4/46quviIuLo23btql2nnz99dds2LCBMWPGMH78eA4fPpyhu7PLly+nQ4cOmJub061bNy5evMixY8f09omJiaFu3brMmzePpk2bMnfuXD744APOnz/PzZs3AdBoNLRu3ZrJkydTpUoVvvvuO0aMGMHTp085c+ZMuuN5WWJiIs2aNcPFxYWZM2fSsWNHIKlRFxsby4cffsi8efNo1qwZ8+bNo3fv3nrHnz59murVq7Nnzx4GDRrE3Llzad++PX/++SeQlIvEw8Mj1Y645cuXU7x4cWrWrPlWsQshhMg80j7Je+2TVyV3SObPn1+3La12wpAhQ/jkk0+oXbs2c+fOpV+/fixfvpxmzZrpdSQGBATQqlUrHj16xPjx4/n666/x9fVlx44dacYRGBhIt27dcHJy4ptvvuHrr7+mQYMGHDhw4LXxBwQE0LlzZ0xMTJg+fTqDBg1i/fr11KlTJ0XHokajoVmzZuTPn5+ZM2dSv359vvvuOxYtWpSua9WvXz927NjB9u3b07V/RqT2u/jbb7/RqlUrbG1t+eabb/jyyy85d+4cderU0etMelO7DDL3d0bkYYoQwugtWbJEAZRdu3Yp9+/fV27cuKGsW7dOcXZ2ViwsLJQbN27o7V+/fn2lbNmyiqIoyuTJkxVAOXHihKIoinL16lUFUL799lvd/nv37lUAZe3atcqTJ08UJycnpW3btrrn+/Tpo9jY2LwxzkePHikWFhZKt27d9LaPGzdOAZTw8HBFURQlNjY2xbGHDh1SAGXZsmUp4tq7d69eLEWKFNE93rhxowIoM2bM0G1LTExU6tatqwDKkiVLdNtTO+/KlSsVQNm/f79u27fffqsAytWrV1PsX6RIEaVPnz66xyNHjlQAJSgoSLctOjpaKVq0qOLl5aVoNBq91+Lj46PEx8fr9p07d64CKKGhoSnO9arjx48rgBIYGKgoiqJotVrF3d1dGTFihN5+EyZMUABl/fr1KcrQarWKoijK4sWLFUCZNWtWmvukdv0V5b/30MvXtk+fPgqgjBs3LkV5qV336dOnKyqVSrl+/bpuW7169RQ7Ozu9bS/HoyiKMn78eMXCwkJ58uSJbtu9e/cUU1NTZeLEiSnOI4QQIutI+2SvXix5sX2S2ntg1apVSv78+RUrKyvl5s2buuuTWjshKChIAZTly5frbd+xY4fe9idPnih2dnZK9erVlefPn+vt+3I74dV6GDFihGJvb68kJiam+Rperc8XL14oLi4uSrly5fTOtWXLFgVQJkyYoHc+QJkyZYpemZUqVVKqVKmS5jmTJSQkKD179lTMzc0VGxsb5eDBg288JjXJvwv3799X7t+/r1y6dEmZOXOmolKplHLlyumuUXR0tOLo6KgMGjRI7/g7d+4oDg4OetvT0y7LzN8ZkXfJSCkhcpAmTZrg7OyMh4cH/v7+2NjYsHnzZtzd3dM8JvluZHpzNzg4ODBy5Eg2b97MyZMnMxSfk5MTLVu2ZPPmzbo8AYqisGrVKvz8/ChVqhQAVlZWumMSEhJ4+PAhJUqUwNHRMcN3QLdt24apqSkffvihbpuJiQnDhg1Lse/L542Li+PBgwfUqFED4K3uvCafv1q1atSpU0e3zdbWlsGDB3Pt2jXOnTunt3+/fv0wNzfXPU6e4vDqsOrULF++nIIFC9KwYUMgaVh2ly5dWLVqld4Q8T/++IOKFSvy/vvvpyhDpVLp9ilQoECq1yl5n7fxcj0ke/m6P3v2jAcPHlCrVi0URdG9x+7fv8/+/fvp378/np6eacbTu3dv4uPjWbdunW7b6tWrSUxMpGfPnm8dtxBCiLcn7ZOU8lL7BPTfA127dsXW1pYNGzZQuHBhvf1ebSesXbsWBwcH3nvvPR48eKD7qVKlCra2tuzduxdIGvEUHR3NuHHjsLS01Cvjde0WR0dHnj17RmBgYLpeB8Dx48e5d+8eH330kd65WrVqRenSpVNMgQT44IMP9B7XrVs3Xdfu008/Zfv27YSGhlK9enVatmxJSEiI7vnIyEhUKhW//vrrG8t69uwZzs7OODs7U6JECcaMGUPt2rXZtGmT7hoFBgby5MkTunXrpne9TUxMqF69uu56p7ddlpm/MyLvkk4pIXKQH374gcDAQNatW0fLli158ODBG+ecv00jbsSIETg6Or5V7oYePXrw7NkzXWLLgwcPcu3aNb0h4M+fP2fChAl4eHhgYWFBgQIFcHZ25smTJzx9+jRD57t+/Tpubm4ploT29vZOse+jR48YMWIEBQsWxMrKCmdnZ4oWLQqQ4fO+fP7UzuXj46N7/mWv/mFPHk6dWt6El2k0GlatWkXDhg25evUqly5d4tKlS1SvXp27d++ye/du3b6XL1+mXLlyry3v8uXLeHt7v9NKQ68yNTVN9QtIREQEffv2JV++fLpcC/Xr1wf+u+7JDbc3xV26dGmqVq2qN4Vv+fLl1KhRgxIlSmTWSxFCCJEB0j5JKa+0T5Ilvwf27t3LuXPnuHLlCs2aNdPbJ7V2wsWLF3n69CkuLi66DpXkn5iYGO7duwf8Nx3wTe2EV3300UeUKlWKFi1a4O7uTv/+/V873Q/+uzapXb/SpUunuHaWlpYpplE6OTm98drdunWL77//nrFjx1KqVCk2btxI0aJFadq0qW4FweSUCtWrV3/9C/03jsDAQAIDA1myZAk+Pj7cu3dPr+Po4sWLQFLOr1ev919//aW73ultl2Xm74zIuzLv24gQIstVq1YNPz8/ANq3b0+dOnXo3r074eHhKRo9LxsxYgSzZ89m8uTJzJkz543nSW4oTpo0KcN3I1u3bo2DgwMrVqyge/furFixAhMTE7p27arbZ9iwYSxZsoSRI0dSs2ZNHBwcUKlUdO3aFa1Wm6HzZUTnzp05ePAgn3zyCb6+vtja2qLVamnevHmWnvdlJiYmqW5XXklw+ao9e/YQGRnJqlWrWLVqVYrnly9fTtOmTTMlxmRp3XlMK3GnhYVFipVrNBoN7733Ho8ePWLs2LGULl0aGxsbbt26Rd++fd/quvfu3ZsRI0Zw8+ZN4uPjOXz4MPPnz89wOUIIITKHtE/eTU5unyR7+T2QltTaCVqtFhcXlzQXbkkrZ1Z6ubi4EBISws6dO9m+fTvbt29nyZIl9O7dm6VLl75T2cnSunZvcuTIETQajW5UnJ2dHdu3b6d27do0adKEoKAgFi1aRMWKFdPVGWdiYkKTJk10j5s1a0bp0qUZMmSIbiXM5PfTb7/9hqura4oyMnqz0lC/MyJ3kU4pIXKo5MSLDRs2ZP78+YwbNy7NfV9uxKWWYDM1I0eOZM6cOUyePBlHR8d0x2VhYYG/vz/Lli3j7t27rF27lkaNGun94Vu3bh19+vThu+++022Li4tLdUWaNylSpAi7d+8mJiZGr+GbfIcp2ePHj9m9ezeTJ09mwoQJuu3Jd4xelpHpa0WKFElxLkharST5+cywfPlyXFxc+OGHH1I8t379ejZs2MDChQuxsrKiePHib0xWXrx4cY4cOUJCQkKaS0gn3yV9tV4yskxxaGgoFy5cYOnSpXqJzV8dRl+sWDGAdCVZ79q1K6NHj2blypU8f/4cMzMzunTpku6YhBBCZB1pnyTJK+2Td1W8eHF27dpF7dq19Ub0pLYfJLUTMjoy2tzcnDZt2tCmTRu0Wi0fffQRP/30E19++WWqZSVfm/DwcN0qgsnCw8Mz7dol1+eNGzd02woWLMjOnTupXbs29evX5+bNm6xfv/6tyndzc2PUqFFMnjyZw4cPU6NGDd11dHFx0evAelV622WZ+Tsj8i6ZvidEDtagQQOqVavGnDlziIuLe+2+I0eOxNHRkSlTpqSr7OSG4qZNm/TmtqdHjx49SEhIYMiQIdy/fz/F6i0mJiYp7rzNmzcv3Uvnvqxly5YkJiayYMEC3TaNRsO8efNSnBNS3vFL7c6sjY0NkLIzJq3zHz16lEOHDum2PXv2jEWLFuHl5UWZMmXS+1LS9Pz5c9avX0/r1q3x9/dP8TN06FCio6N1d8E6duzIqVOnUl1dJ/n1d+zYkQcPHqQ6wih5nyJFimBiYsL+/fv1nv/xxx/THXtq111RFL2lmCHpTmi9evVYvHgxERERqcaTrECBArRo0YLff/+d5cuX07x5cwoUKJDumIQQQmQtaZ/kjfZJZujcuTMajYapU6emeC4xMVH3Wps2bYqdnR3Tp09P8Z563Wiuhw8f6j1Wq9VUqFABgPj4+FSP8fPzw8XFhYULF+rts337dsLCwmjVqlW6Xtub1KlTBwsLC77++mu9leqKFy/OnDlziIiIwMHBQZfy4G0MGzYMa2trvv76ayBp9JS9vT3Tpk3TW9kw2f3794H0t8sy83dG5F0yUkqIHO6TTz6hU6dOBAQEpEiy+DIHBwdGjBiR7oSi8N+w+lOnTukaQulRv3593N3d2bRpE1ZWVnTo0EHv+datW/Pbb7/h4OBAmTJlOHToELt27dJbNji92rRpQ+3atRk3bhzXrl2jTJkyrF+/PsU8dnt7e+rVq8eMGTNISEigcOHC/PXXX1y9ejVFmVWqVAHg888/p2vXrpiZmdGmTZtUr8G4ceNYuXIlLVq0YPjw4eTLl4+lS5dy9epV/vjjjxTD1N/G5s2biY6Opm3btqk+X6NGDZydnVm+fDldunThk08+Yd26dXTq1In+/ftTpUoVHj16xObNm1m4cCEVK1akd+/eLFu2jNGjR3P06FHq1q3Ls2fP2LVrFx999BHt2rXDwcGBTp06MW/ePFQqFcWLF2fLli26fAPpUbp0aYoXL86YMWO4desW9vb2/PHHH6nmWfj++++pU6cOlStXZvDgwRQtWpRr166xdevWFF88evfujb+/P0CqDVkhhBCGJe2T3N8+yQz169dnyJAhTJ8+nZCQEJo2bYqZmRkXL15k7dq1zJ07F39/f+zt7Zk9ezYDBw6katWqdO/eHScnJ06dOkVsbGyaU/EGDhzIo0ePaNSoEe7u7ly/fp158+bh6+ury6/1KjMzM7755hv69etH/fr16datG3fv3mXu3Ll4eXkxatSoTHntzs7OTJ8+ndGjR1O+fHn69++Pq6srx48fZ+nSpdSoUYPg4GD8/f3Zvn17miPbXyd//vz069ePH3/8kbCwMHx8fFiwYAG9evWicuXKdO3aFWdnZyIiIti6dSu1a9fW3bBMT7ssM39nRB6W7ev9CSEyLHm53WPHjqV4TqPRKMWLF1eKFy+uW+725SWXX/b48WPFwcHhtUsuv2rixIkKkK4ll1/2ySefKIDSuXPnVOPo16+fUqBAAcXW1lZp1qyZcv78+RTLGad3+diHDx8qvXr1Uuzt7RUHBwelV69eysmTJ1MsuXzz5k3l/fffVxwdHRUHBwelU6dOyu3btxVAmThxol6ZU6dOVQoXLqyo1Wq95ZdfjVFRFOXy5cuKv7+/4ujoqFhaWirVqlVTtmzZordPWtc4eQnsl+N8VZs2bRRLS0vl2bNnae7Tt29fxczMTHnw4IHumgwdOlQpXLiwYm5urri7uyt9+vTRPa8oScv4fv7550rRokUVMzMzxdXVVfH391cuX76s2+f+/ftKx44dFWtra8XJyUkZMmSIcubMmRQxv25Z7nPnzilNmjRRbG1tlQIFCiiDBg1STp06lerrPnPmjK6OLC0tFW9vb+XLL79MUWZ8fLzi5OSkODg4pFgaWgghRPaQ9sle3ba82D5RlNe/B172unaCoijKokWLlCpVqihWVlaKnZ2dUr58eeXTTz9Vbt++rbff5s2blVq1ailWVlaKvb29Uq1aNWXlypV653m5HtatW6c0bdpUcXFxUczNzRVPT09lyJAhSmRkZIpr8HJ9KoqirF69WqlUqZJiYWGh5MuXT+nRo4dy8+bNdL2u5PdnemzcuFGpW7euYmNjo1hZWSl+fn7KggULlMTERGXRokUKoPTv3/+1Zbzu+l6+fFkxMTFJ8R5u1qyZ4uDgoFhaWirFixdX+vbtqxw/flzv2De1yzL7d0bkTSpFSWf2OiGEEMJIJCYmUqhQIdq0aZOuZZKFEEIIIYQQxsc4xm0KIYQQGbBx40bu37+vlzxdCCGEEEIIkbPISCkhhBA5xpEjRzh9+jRTp06lQIECBAcHGzokIYQQQgghxFuSkVJCCCFyjAULFvDhhx/i4uLCsmXLDB2OEEIIIYQQ4h3ISCkhhBBCCCGEEEIIke1kpJQQQgghhBBCCCGEyHbSKSWEEEIIIYQQQgghsp10SgkhhBBCCCGEEEKIbGdq6AByKq1Wy+3bt7Gzs0OlUhk6HCGEEEJkE0VRiI6OplChQqjVcn/vdaS9JIQQQuRN6W0vSafUW7p9+zYeHh6GDkMIIYQQBnLjxg3c3d0NHYZRk/aSEEIIkbe9qb0knVJvyc7ODki6wPb29pladkJCAn/99RdNmzbFzMwsU8sW707qx3hJ3Rg3qR/jJvWTflFRUXh4eOjaAiJt0l7Ku6R+jJvUj/GSujFuUj/pl972knRKvaXkIej29vZZ0siytrbG3t5e3uhGSOrHeEndGDepH+Mm9ZNxMh3tzaS9lHdJ/Rg3qR/jJXVj3KR+Mu5N7SVJhCCEEEIIIYQQQgghsp2MlBIiD9NoNQRFBBEZHYmbnRt1PetiojYxdFhCCCGEEEIIIbKQVqMlIiiC6Mho7Nzs8Kzridok+8ctSaeUEHnU+rD1jNgxgptRN3Xb3O3dmdt8Lh18OhgwMiGEEEIIIYQQWSVsfRg7Ruwg6maUbpu9uz3N5zbHp4NPtsYinVJC5EHrw9bjv8YfBUVv+62oW/iv8Wdd53XSMSWEEEKIXEuj0ZCQkGDoMAwmISEBU1NT4uLi0Gg0hg5HvORt68bMzAwTE5nxIN4sbH0Ya/zX8MpXQaJuRbHGfw2d13XO1o4p6ZQSIo/RaDWM2DEiRYcUgIKCChUjd4yknXc7mconhBBCiFxFURTu3LnDkydPDB2KQSmKgqurKzdu3JBFG4zMu9SNo6Mjrq6uUqciTVqNlh0jdqTokAKStqlgx8gdeLfzzrapfNIpJUQeExQRpDdl71UKCjeibhAUEUQDrwbZF5gQQgghRBZL7pBycXHB2to6z35512q1xMTEYGtri1ota18Zk7epG0VRiI2N5d69ewC4ubllZYgiB4sIitCbspeCAlE3oogIisCrgVe2xCSdUkLkMZHRkZm6nxBCCCFETqDRaHQdUvnz5zd0OAal1Wp58eIFlpaW0illZN62bqysrAC4d+8eLi4uMpVPpCo6MjpT98sM8gkkRB7jZpe+Oyfp3U8IIYQQIidIziFlbW1t4EiEyBrJ7+28nC9NvJ6dm12m7pcZpFNKiDymrmdd3O3d03xehQoPew/qetbNxqiEEEIIIbJHXp2yJ3I/eW+LN/Gs64m9u33aO6jA3sMez7qe2RaTdEoJkceYqE2Y23xums8rKIypNUaSnAshhBBC5BINGjRg5MiRusfFihVjwYIFrz1GpVKxcePGdz53ZpVjjF69rpm1rxBZRW2ipvnc5qk/+W+fZvM5zbMtyTlIp5QQeVIl10qpbjdTmwEw/Z/phD8Iz86QhBBCCCFyBK1Gy7V91whdGcq1fdfQarRZdq42bdrQvHnqXyCDgoJQqVScPn06w+UeOXKEPn36vGt4eiZNmoSvr2+K7ZGRkbRo0SJTz/WqgIAAVCoVKpUKtVqNu7s7/fr10yX+zirr169n6tSpmb6vEFmpQOkCqW63d7en87rO+HTwydZ4JNG5EHnQryd/BaBJ0SZ8Xu9zIqMjcbNzw6eAD+/99h6h90JpuLQh+/ruo1T+UgaOVgghhBDCOIStD2PHiB16q1fZu9vTfG7zLPkiN2DAADp27MjNmzdxd9dPv7BkyRL8/PyoUKFChst1dnYmKuo1K3BlIldX12w5j729PeHh4Wi1Wk6dOkW/fv24ffs2O3fuTLGvRqPRdWC9i3z58mXJvkJkpaM/HAXAu703NUbUIDoyGjs3OzzrembrCKlkMlJKiDwmUZvIkpAlAAyuMpgGXg3oVr4bDbwaUNC2ILt776acSzkiYyJpuLQhFx9eNHDEQgghhBCGF7Y+jDX+a1Ispx51K4o1/msIWx+W6eds3bo1zs7OBAQE6G2PiYlh7dq1DBgwgIcPH9KtWzcKFy6MtbU15cuXZ+XKla8t99XpexcvXqRevXpYWlpSpkwZAgMDUxwzduxYSpUqhbW1NcWKFePLL7/UJdQOCAhg8uTJnDp1SjdiKTnmV6fvhYaG0qhRI6ysrMifPz+DBw8mJiZG93zfvn1p3749M2fOxM3Njfz58/Pxxx+/MXm3SqXC1dWVQoUK0aJFC4YPH86uXbt4/vw5AQEBODo6snnzZsqUKYOFhQURERHEx8czZswYChcujI2NDdWrV2ffvn165R44cIAGDRpgbW2Nk5MTzZo14/Hjx0DKKXk//vgjJUuWxNLSkoIFC+Lv76977tV9Hz9+TO/evXFycsLa2poWLVpw8eJ/7e7kmHfu3ImPjw+2trY0b96cyEhZIVu8vbincZxaegqA6sOq49XAi/LdyuPVwMsgHVIgnVJC5Dk7Lu3gdvRtClgXoK132xTPO9s4s7v3bso6l+V29G0aLm3IpUeXDBCpEEIIIUTWURSFF89epOsnLiqO7cO3g5JaQUn/bB+xnbiouHSVpyipFZSSqakpvXv3JiAgQO+YtWvXotFo6NatG3FxcVSpUoWtW7dy5swZBg8eTK9evTh69Gi6zqHVaunQoQPm5uYcOXKEhQsXMnbs2BT72dnZERAQwLlz55g7dy4///wzs2fPBqBLly7873//o2zZskRGRhIZGUmXLl1SlPHs2TOaNWuGk5MTx44dY+3atezatYuhQ4fq7bd3714uX77M3r17Wbp0KQEBASk65t7EysoKrVZLYmIiALGxsXzzzTf88ssvnD17FhcXF4YOHcqhQ4dYtWoVp0+fplOnTjRv3lzXORQSEkLjxo0pU6YMhw4d4p9//qFNmzZoNJoU5zt+/DjDhw9nypQphIeHs2PHDurVq5dmfH379uX48eNs3ryZQ4cOoSgKLVu21Ot8i42NZebMmfz222/s37+fiIgIxowZk6HrIMTLTi07RcKzBJzLOOPV0MvQ4QAyfU+IPOfn4J8B6FOxDxamFqnu42Ljwp4+e2i4tCHn7p9LmsrXZx/F8xXPzlCFEEIIIbJMQmwC022nZ05hCkTfjOYbh2/Stfv4mPGY25ina9/+/fvz7bff8vfff9OgQQMgaepex44dcXBwwMHBQa+jYtiwYezcuZM1a9ZQrVq1N5a/a9cuzp8/z86dOylUqBAA06ZNS5EH6osvvtD938vLizFjxrBq1So+/fRTrKyssLW1xdTU9LXT9VasWEFcXBzLli3DxsYGgPnz59OmTRu++eYbChYsCICTkxPz58/HxMSE0qVL06pVK3bv3s2gQYPSdc0uXrzIwoUL8fPzw84uaWn7hIQEfvzxRypWrAhAREQES5YsISIiQve6x4wZw44dO1iyZAnTpk1jxowZ+Pn58eOPP+rKLlu2bKrnjIiIwMbGhtatW2NnZ0eRIkWoVCn1PK4XL15k8+bNHDhwgFq1agGwfPlyPDw82LhxI82aNdPFvHDhQooXT2qDDx06lClTpqTrGgjxKkWrcGz+MQCqDq1qNKs1ykgpIfKQ29G32XphKwADKg147b4uNi7s6b2H0gVKczPqJg2XNuTK4yvZEaYQQgghhPhX6dKlqVWrFosXLwbg0qVLBAUFMWBAUltOo9EwdepUypcvT758+bC1tWXnzp1ERESkq/ywsDA8PDx0HTMANWvWTLHf6tWrqV27Nq6urtja2vLFF1+k+xwvn6tixYq6DimA2rVro9VqCQ//b5GdsmXLYmLy30rQbm5ub0xa/vTpU2xtbbG2tsbb25uCBQuyfPly3fPm5uZ6+bdCQ0PRaDSUKlUKW1tb3c/ff//N5cuXgf9GSqXHe++9R5EiRShWrBi9evVi+fLlxMbGpnkdTE1NqV69um5b/vz58fb25vz587pt1tbWug6p9F4HIdJyZfcVHl54iIW9BRV7VTR0ODoyUkqIPCQgJACNoqGOZx18nN+cjLOgbUH29E4aMRX+MJyGSxvyd9+/8XL0yvpghRBCCCGykJm1GeNjxqdr3+v7r7Oi5Yo37td9W3eK1CuSrnNnxIABAxg2bBg//PADS5YsoXjx4tSvXx+Ab7/9lrlz5zJnzhzKly+PjY0NI0eO5MWLFxk6x+scOnSIHj16MHnyZJo1a4aDgwOrVq3iu+++y7RzvMzMTP/6qFQqtNrXr3JoZ2dHcHAwarUaNzc3rKys9J63srLSGxkSExODiYkJJ06c0OsAA7C1tdUdk17J59+3bx9//fUXEyZMYNKkSRw7dgxHR8d0l/Oy1K5Deqd+CvGqo/OSpvRW7FsRc9v0jdTMDjJSSog8QqtodavuDaw0MN3Hudm5sbfPXkrlL0XE0wgaLm3I9SfXsypMIYQQQohsoVKpMLcxT9dP8abFsXe3h7Rmu6jA3sOe4k2Lp6u8jE6b6dy5M2q1mhUrVrBs2TL69++vK+PAgQO0a9eOnj17UrFiRYoVK8aFCxfSXbaPjw83btzQS6B9+PBhvX0OHjxIkSJF+Pzzz/Hz86NkyZJcv67fHjQ3N08119Kr5zp16hTPnj3TbTtw4ABqtRpvb+90x5watVpNiRIlKFasWLo6kypVqoRGo+HevXuUKFFC7yd5CmKFChXYvXt3umMwNTWlSZMmzJgxg9OnT3Pt2jX27NmTYj8fHx8SExM5cuSIbtvDhw8JDw/HxyfzV3EU4vHVx1zYkvS5UPWjqgaORp90SgmRR+y9upcrj69gb2FPp7KdMnRscsdUyXwlufbkGg2XNiTiacaGawshhBBC5FRqEzXN5zZPevBqf9K/j5vPaZ5lq1fZ2trSpUsXxo8fT2RkJH379tU9V7JkSQIDAzl48CBhYWEMGTKEu3fvprvsJk2aUKpUKfr06cOpU6cICgri888/19unZMmSREREsGrVKi5fvsz333/Phg0b9Pbx8vLi6tWrhISE8ODBA+Lj41Ocq0ePHlhaWtKnTx/OnDnD3r17GTZsGL169dLlk8oupUqVokePHvTu3Zv169dz9epVjh49yvTp09m6NSndxfjx4zl27BgfffQRp0+f5vz58yxYsIAHDx6kKG/Lli18//33hISEcP36dZYtW4ZWq021s61kyZK0a9eOQYMG8c8//3Dq1Cl69uxJ4cKFadeuXZa/dpH3HF9wHBQo3rQ4BbwLGDocPdIpJUQe8cvJXwDoUb4H1mbWGT6+kF0h9vbZS3Gn4lx9cpWGSxty4+mNzA5TCCGEEMIo+XTwofO6ztgXttfbbu9uT+d1nfHpkLUjXAYMGMDjx49p1qyZXv6nL774gsqVK9OsWTMaNGiAq6sr7du3T3e5arWaDRs28Pz5c6pVq8bAgQP56quv9PZp27Yto0aNYujQofj6+nLw4EG+/PJLvX06duxI8+bNadiwIc7OzqxcuTLFuaytrdm5cyePHj2iatWq+Pv707hxY+bPn5+xi5FJlixZQu/evfnf//6Ht7c37du359ixY3h6egJJHVd//fUXp06dolq1atSsWZNNmzZhapoyC46joyPr16+nUaNG+Pj4sHDhQlauXJlmYvQlS5ZQpUoVWrduTc2aNVEUhW3btqWYsifEu0qITSD4l2AgKcG5sVEpMin1rURFReHg4MDTp0+xt7d/8wEZkJCQwLZt22jZsqV8KBmhnFg/D2IfUHhWYV5oXnBi8Akqu1V+67JuPL1Bg6UNuPL4CsWdirOv7z7c7d0zL9h3kBPrJi+R+jFuUj/pl5VtgNxG2kt5lzHWT1xcHFevXqVo0aJYWlq+dTlajZaIoAiiI6Oxc7PDs65nlo2QyiparZaoqCjs7e1Rq3NW7Lndu9RNZr3HRdqM8bPtTU4uPsnmAZtxLOrIsIvDsu3zKr1tAPkEEiIP+P3077zQvKCyW+V36pAC8HDwYG+fvRR1LMrlx5dptLQRt6JuZVKkQgghhBDGTW2ixquBF+W7lcergVeO65ASQuQdiqLoEpxX/aiqUX5eGV9EQohMpSgKvwQnTd3LSILz1/F08GRvn714OXpx8dFFGi1rxO3o25lSthBCCCGEEEKId3fj4A3uhNzB1NKUSv0rGTqcVEmnlBC53OGbhzl7/yxWplZ0L98908ot4liEvX32UsShCBceXqDR0kZERke++UAhhBBCCCGEEFnu2PxjAJTvUR6rfG9eldIQpFNKiFwueZRU57KdcbB0yNSyvRy92NtnL54OnoQ/DKfRskbcibmTqecQQgghhBBCCJEx0ZHRnFt3DoCqHxtfgvNk0iklRC4WFR/FqrOrABhUeVCWnKOoU1H29tmLu7075x+cp/GyxtyNSf8yxEIIIYQQQgghMteJRSfQJmrxqO2BWyU3Q4eTJumUEiIXW3VmFbEJsfgU8KGWR60sO08xp2Ls67OPwnaFOXf/HI2XNebes3tZdj4hhBBCCCGEEKnTvNBwYuEJAKoNq2bgaF5POqWEyMV+Dv4ZgIGVB6JSqbL0XMXzFWdf330UsivE2ftnabysMfef3c/ScwohhBBCCCGE0Be2PoyYOzHYutni876PocN5LemUEiKXCrkTwvHbxzFTm9GrQq9sOWeJfCXY12cfbrZunLl3hsbLGvMg9kG2nFsIIYQQQgghBBydfxSAKkOqYGJuYuBoXk86pYTIpZITnLcv3R5nG+dsO2/J/CXZ22cvrrauhN4LpcmyJjyMfZht5xdCCCFyGq1Gy7V91whdGcq1fdfQarSGDkkIIUQOFXkykhsHbqA2VVNlcBVDh/NGRtEp9cMPP+Dl5YWlpSXVq1fn6NGjae4bEBCASqXS+7G0tNQ9n5CQwNixYylfvjw2NjYUKlSI3r17c/v2bb1yvLy8UpTz9ddfZ9lrFCI7PU94zu+nfweyLsH563gX8GZvn70UtCnIqbunaPJbEx49f5TtcQghhBDGLmx9GHO95rK04VLWd1/P0oZLmes1l7D1YYYOTeQiDRo0YOTIkbrHxYoVY8GCBa89RqVSsXHjxnc+d2aVkxO8ep29vLyYM2eOweIRedOxH44BUMa/DHZudgaO5s0M3im1evVqRo8ezcSJEwkODqZixYo0a9aMe/fSTpJsb29PZGSk7uf69eu652JjYwkODubLL78kODiY9evXEx4eTtu2bVOUM2XKFL1yhg0bliWvUYjs9kfYHzyNf4qXoxeNizU2SAylC5Rmb5+9uNi4EHInhCbLpGNKCCGEeFnY+jDW+K8h6maU3vaoW1Gs8V8jHVPGSqOBfftg5cqkfzWaLDtVmzZtaN68earPBQUFoVKpOH36dIbLPXLkCH369HnX8PRMmjQJX1/fFNsjIyNp0aJFpp7rVS8PXFCr1bi5udGlSxciIiKy9LxCGJvnj54TujwUgKpDqxo4mvQxeKfUrFmzGDRoEP369aNMmTIsXLgQa2trFi9enOYxKpUKV1dX3U/BggV1zzk4OBAYGEjnzp3x9vamRo0azJ8/nxMnTqT4ULKzs9Mrx8bGJstepxDZKTnB+YBKA1CrDPdr7uPsw94+e3G2dubknZM0/a0pj58/Nlg8QgghhLHQarTsGLEDlFSe/HfbjpE7ZCqfsVm/Hry8oGFD6N496V8vr6TtWWDAgAEEBgZy8+bNFM8tWbIEPz8/KlSokOFynZ2dsba2zowQ38jV1RULC4ssP0/ywIVbt27xxx9/EB4eTqdOnbL8vEIYk5OLT5IYl4hrJVc8ankYOpx0MTXkyV+8eMGJEycYP368bptaraZJkyYcOnQozeNiYmIoUqQIWq2WypUrM23aNMqWLZvm/k+fPkWlUuHo6Ki3/euvv2bq1Kl4enrSvXt3Ro0ahalp6pckPj6e+Ph43eOoqKQ7WgkJCSQkJKTn5aZbcnmZXa7IHMZePxceXmD/9f2oVWp6lO1h8DhLOpZkZ/edNF3elBORJ2j6W1O2dduGo6Vjpp/L2Osmr5P6MW5SP+kn10hkhoigiBQjpPQoEHUjioigCLwaeGVbXOI11q8Hf39QXulJvHUrafu6ddChQ6aesnXr1jg7OxMQEMAXX3yh2x4TE8PatWv59ttvefjwIUOHDmX//v08fvyY4sWL89lnn9GtW7c0yy1WrBhDhgxh7NixAFy8eJEBAwZw9OhRihUrxty5c1McM3bsWDZs2MDNmzdxdXWlR48eTJgwATMzMwICApg8eTKAbsXnJUuW0LdvX1QqFRs2bKB9+/YAhIaGMmLECA4dOoS1tTUdO3Zk1qxZ2NraAtC3b1+ePHlCnTp1+O6773jx4gVdu3Zlzpw5mJmZpfmakgcuALi5uTFgwACGDx9OVFQU9vb2AGzatInJkydz7tw5ChUqRJ8+ffj888913wGfPHnC2LFj2bhxI0+fPqVEiRJ8/fXXtG7d+q2usxDZSavR6qbuVRtaLctXX88sBu2UevDgARqNRm+kE0DBggU5f/58qsd4e3uzePFiKlSowNOnT5k5cya1atXi7NmzuLu7p9g/Li6OsWPH0q1bN92HEcDw4cOpXLky+fLl4+DBg4wfP57IyEhmzZqV6nmnT5+u+6B92V9//ZVldxkCAwOzpFyROYy1fgJuBwBQ2a4yp/85zWkyPqQ7K3zh+QVfXvqS45HHqb2wNpOKT8LGJGtGJxpr3YgkUj/GTernzWJjYw0dQqp++OEHvv32W+7cuUPFihWZN28e1apVS3XfgIAA+vXrp7fNwsKCuLi4VPf/4IMP+Omnn5g9e7ZevhTx9qIjozN1P/EWFAXS+/us0cDw4Sk7pJLLUalgxAho0gRM0rHSlbV10jFvYGpqSu/evQkICODzzz/Xfclcu3YtGo2Gbt26ERMTQ5UqVRg7diz29vZs3bqVXr16Ubx48TQ/A16m1Wrp0KEDBQsW5MiRIzx9+jTV33M7OzsCAgIoVKgQoaGhDBo0CDs7Oz799FO6dOnCmTNn2LFjB7t27QKSZrC86tmzZzRr1oyaNWty7Ngx7t27x8CBAxk6dCgBAQG6/fbu3Yubmxt79+7l0qVLdOnSBV9fXwYNSl+u1Hv37rFhwwZMTEww+bc+goKC6N27N99//z1169bl8uXLDB48GICJEyei1Wpp0aIF0dHR/P777xQvXpxz587pjo+Li3un6yxEVru47SJPrj3BKp8V5bqVM3Q46WbQTqm3UbNmTWrWrKl7XKtWLXx8fPjpp5+YOnWq3r4JCQl07twZRVFSJPIbPXq07v8VKlTA3NycIUOGMH369FSHl44fP17vmKioKDw8PGjatKleZ1dmSEhIIDAwkPfee++1dwOEYRhz/bzQvGDwvKQ/ruOajqNlqZYGjkhf7bu1ab6iORdjLzL34Vy2dduGvUXm/f4Yc90IqR9jJ/WTfsmjpY1Jco7OhQsXUr16debMmUOzZs0IDw/HxcUl1WPs7e0JDw/XPU7rjuqGDRs4fPgwhQoVypLY86r0Jp/NCUlqc6zYWPh3dM47UxS4eRNS6YhJVUwMpDN1SP/+/fn222/5+++/adCgAZA0Cqljx444ODjg4ODAmDFjdPsPGzaMnTt3smbNmnR1luzatYvz58+zc+dO3e/5tGnTUuSBenmklpeXF2PGjGHVqlV8+umnWFlZYWtri6mpqW60UmpWrFhBXFwcy5Yt06VOmT9/Pm3atOGbb77RDVZwcnJi/vz5mJiYULp0aVq1asXu3btf2yn19OlTbG1tURRFd/Ng+PDhuvNMnjyZcePG6XJpFStWjKlTp/Lpp58yceJEdu3axdGjRwkLC6NUqVK6fZIVLlz4na6zEFnt2PykUVKVBlTCzCrntOUM2ilVoEABTExMuHv3rt72u3fvvvbD7GVmZmZUqlSJS5cu6W1P7pC6fv06e/bseWPHUfXq1UlMTOTatWt4e3uneN7CwiLVziozM7Msa7xnZdni3Rlj/Wy+uJl7sfdws3WjnU87TNXG1e/s5+7Hrt67aLysMUdvH6XN6jbs6LkjUzumwDjrRvxH6se4Sf28mTFen5dzdAIsXLiQrVu3snjxYsaNG5fqMS9PdUnLrVu3dF+8WrVqlelx52WedT2xd7dPewqfCuzd7fGs65m9gQmjU7p0aWrVqsXixYtp0KABly5dIigoiClTpgCg0WiYNm0aa9as4datW7x48YL4+Ph0z+YICwvDw8NDr+P55UEAyVavXs3333/P5cuXiYmJITExMcM358PCwqhYsaJeLt/atWuj1WoJDw/XdUqVLVtWN0IJkqbjhYaGvrZsOzs7goODSUhIYPv27SxfvpyvvvpK9/ypU6c4cOCA3jaNRkNcXByxsbGEhITg7u6u65B61bteZyGy0oPwB1z+6zKowO9DP0OHkyEG/cZqbm5OlSpV2L17t26OsVarZffu3QwdOjRdZWg0GkJDQ2nZ8r8RIckdUhcvXmTv3r3kz5//jeWEhISgVqvTvJsoRE7wy8lfAOjr29foOqSS+br6EtgrkCbLmnDo5iFaLG/Bjh47sLOQO8FCCPE2sipHp1arpVevXnzyySevzd35MsnBmTFNvmvC+i5pJ8huMrMJGq0GjTbrVnfLKsZYPwkJCSiKglarRavVgqUlpHfkY1AQ6nR0zGq3boW6dd9cnqUlaNOfxL5fv36MGDGCefPmsXjxYooXL07dunXRarXMmDGDuXPnMmvWLMqXL4+NjQ2jRo0iPj4+6XX+K/m1v0xRFJR/pyS+/Fzy/5Ov1aFDh+jRoweTJk2iadOmODg4sHr1ambNmqXbN7VyXi5Pq9Wm61yKomBqapqiHF29pUKr1aJWq3Ujm7y9vbl06RIffPABy5YtA5I+8yZNmsT777+f4nhzc3MsLS3TjB946+uc2nV/neRrlNHjkmNXFIWEhAS9Tj2ReYzxsw3gyPwjAJRsWRJbd1ujiC+9MRj8W+vo0aPp06cPfn5+VKtWjTlz5vDs2TPdnb7evXtTuHBhpk+fDsCUKVOoUaMGJUqU4MmTJ3z77bdcv36dgQMHAkkv3N/fn+DgYLZs2YJGo+HOnTsA5MuXD3Nzcw4dOsSRI0do2LAhdnZ2HDp0iFGjRtGzZ0+cnJwMcyGEeEfXn1xn56WdQNKqe8asslvlpI6p35pw8MZBWq5oyfYe27E1z6Qh9EIIkYdkVY7Ob775BlNTU4YPH57uWCQHZ8Zo1VrUlmq0cSm/eBbsVJArFle4su2KASLLPMZUP8lTy2JiYnjx4kXGDq5eHftChVBFRqJKJa+UolKhFCpEVPXqSfmn3iQ6Y7nCmjdvjlqtZvHixSxdupT+/fsT/W8Zf//9Ny1atKBt27YAulFH3t7euo7hxMREXrx4oXuc3NkRHR2Np6cnN27c4MKFC7rRk3v27AHg+fPnREVFsXfvXjw8PPQGDly6dAlFUfTKfPkcL0sux8vLi4CAACIjI3WjpQIDA1Gr1RQqVIioqCgSEhJITEzUK+fFixcptr0sLi5OLxaAjz76iMqVKzNo0CAqVqxIhQoVOHPmDEOGDElxfExMDMWLF+fmzZsEBwdTokSJFPu87XWOi4t7q2nf0Rl8j0DSdXr+/Dn79+8nMTExw8eL9DOmzzbNcw1nfz0LgLaqlm3bthk4oiTpzcFp8E6pLl26cP/+fSZMmMCdO3fw9fVlx44duoZVREQEavV/S9o/fvyYQYMGcefOHZycnKhSpQoHDx6kTJkyQNIw882bNwPg6+urd669e/fSoEEDLCwsWLVqFZMmTSI+Pp6iRYsyatQovZxRQuQ0S0KWoKDQqGgjiucrbuhw3qhKoSq6EVP/RPxDy+Ut2dZjm3RMCSFENnhTjs4TJ04wd+5cgoODM7R6j+TgzJiwdWGcjjuNbSFb2ixpQ+zdWML+COPCpgs4PHfQmwmQ0xhj/cTFxXHjxg1sbW11o2IyZO5c6NwZRaXS65hSkn9H5szBPotucNvb29O5c2emTp1KVFQUQ4YM0f1O+fj48Mcff3DmzBmcnJyYPXs29+/fp2zZsrp9TE1NMTc31z1O/n5lZ2dH27ZtKVWqFMOGDWPGjBlERUXpBgRYWVlhb29PuXLluHnzJtu2baNq1aps27aNrVu3olKpdGV6e3sTERHBlStXcHd3x87OTpf+JLmcAQMG8M033zB8+HAmTpzI/fv3GT9+PD179tR1BJmZmWFqaqr3mWFubp5i28ssLS31YgEoU6YM7du3Z8aMGfz5559MmjSJtm3bUrx4cTp27IharebUqVOcPXuWqVOn0qJFC+rVq0e/fv2YOXMmJUqU4Pz586hUKpo3b/7W19nS0jJDn3+KohAdHY2dnV2GV0+Li4vDysqKevXqvd17XLyRMX62nVh4gtDnoeQrlY/O4zqjUhvHqnvp7Yw1eKcUwNChQ9Ocrrdv3z69x7Nnz2b27NlpluXl5aUb8piWypUrc/jw4QzHKYSx0mg1LD65GICBlQYaOJr08yvkpxsxFRQRROsVrdnafSs25lmzKp8QQuRGWZGjMygoiHv37uHp+V8+I41Gw//+9z/mzJnDtWvXUi1HcnBmTOhvSTlyfPv4UqppUh6bwn6FubDpAhe3XuTZ7Wc4FnE0YITvzpjqR6PRoFKpUKvVeje9083fH9atS1pl7+ZN3WaVuzvMmYOqQ4dMjDalgQMHsnjxYlq2bKm36viXX37J1atXadGiBdbW1gwePJj27dvz9OlTvdeZ/NpfplKpMDExYcOGDQwYMIAaNWrg5eXF999/rxudpVarad++PaNGjWL48OHEx8fTqlUrvvzySyZNmqQrs1OnTmzcuJHGjRvz5MkTlixZQt++fQF05dja2rJz505GjBhB9erVsba2pmPHjsyaNUtXjkqlShFrcudMWvWWvP3V50ePHk3NmjU5fvw4LVq0YMuWLUyZMoUZM2ZgZmZG6dKlGThwoO64P/74gzFjxtCjRw+ePXtGiRIl+Prrr1Gr1W99nVO77q+TPIoto8clv36VSmVUv3e5lbFcY0VROLHgBADVhlbD3MLcwBH9J73Xxyg6pYQQ7+avy39xI+oG+azy8b5Pynnyxqxq4ar81fMvmv7elL+v/02blW3Y0n0L1maSNFIIIdIjK3J09urViyZNmujt06xZM3r16qVLsSDeTfTtaC7vvAyAb19f3XZnH2eKNirK1T1XOb7wOE2mN0mjBGEQHTpAu3YQFASRkeDmlpRDKhvy99SsWTPVm+/58uVj48aNrz321Rv9V65c0RvFUKpUKYKCgvT2efVcM2bMYMaMGXrbRo4cqfu/hYUF69atS3HuV8spX768bnpgagICAlJsmzNnTpr7A/Tt21fXAfayGjVq6J2/WbNmNGvWLM1y8uXLx+LFi9N8LqPXOa0OfCEyy7W913gQ9gBzW3N8+/gaOpy3Ip1SQuQCyQnOe1XohaVpzhuqW929Ojt67KDZ783Ye20vbVa24c9uf0rHlBBCpFNm5+jMnz9/ioVizMzMcHV1TXWVYpFxp347haJV8KjtQf5S+te66sdVubrnKid/OUmDiQ0wtZQmu1ExMYEGDQwdhRBCcHT+UQAq9K6AhX3Kkco5wVuMWxVCGJO7MXfZHJ6UR21g5Zwzde9VNT1qsqPnDmzNbdlzdQ/tVrXjecJzQ4clhBA5QpcuXZg5cyYTJkzA19eXkJCQFDk6IyMjdfsn5+j08fGhZcuWREVF6eXoFFlLURRCloQA4NvPN8Xz3m29sXe3J/ZBLGfXns3e4IQQQuQITyOeEr4pHIBqH1czcDRvT267CJHDLT21lERtIjXca1DOpZyhw3kntTxq6UZM7bqyi3ar2rGp6yaszKwMHZoQQhi9zMzRmRqZhpJ5bh6+ycPwh5hZm1G2c9kUz6tN1VT5oAp7v9jLsR+OUbFXRQNEKYQQwpgdW3AMRatQtHFRnMs4GzqctyYjpYTIwRRF4ZfgpKl7gyoPMnA0maO2Z22299iOjZkNgVcCeX/1+8Qlxhk6LCGEECLTJI+SKuNfBgu71KdbVB5YGbWZmltHbnH7+O1sjE4IIYSxS4xLJPjnYCApwXlOJp1SQuRg+6/v5+Kji9ia29K5bGdDh5Np6hapy9buW7E2s2bn5Z10WN2B+MR4Q4clhBBCvLOE2ATOrDoDpD51L5ltQVvKdkoaRXXsh2PZEZoQQogc4szqMzx/+BwHTwdKtS5l6HDeiXRKCZGD/Rz8MwDdynXD1tzWwNFkrvpe9dnafStWplZsv7Sdjms6SseUEEKIHC9sfRgvol/gWNSRIvWKvHbfqh9XBeDMqjPEPozNjvDyhNRWsBMiN5D3dt6gKApH5yUlOPf70A+1ac7u1snZ0QuRhz1+/ph155KW3c0tU/de1cCrAVu6b8HK1IqtF7fiv9ZfOqaEEELkaMlT9yr2qYhKrXrtvu413XH1dSUxLpGTi09mQ3S5m5mZGQCxsdLBJ3Kn5Pd28ntd5E63jt4i8kQkJhYmVBpQydDhvDNJdC5EDrU8dDnxmngqFKyAXyE/Q4eTZRoVbcSf3f6k9crWbLmwhc7rOrO201rMTcwNHZoQQgiRIU+uPeHqnqsA+PbxfeP+KpWKqkOr8ufAPzm+4Dg1R9dEbSL3lN+WiYkJjo6O3Lt3DwBra2tUqtd3DOZWWq2WFy9eEBcXh1ot7ylj8jZ1oygKsbGx3Lt3D0dHR0xMTLI4SmFIx+YnTeku17UcNs42Bo7m3UmnlBA5kKIouql7gyoPyvUNqsbFGrO562barGzD5vDNdFnXhTX+azAzkbtAQgghco6QpSEAFG1UFEcvx3QdU75beQI/CeTJ1Sdc2n4px+cOMTRXV1cAXcdUXqUoCs+fP8fKyirXtyNzmnepG0dHR917XOROMXdjOLM6KS9htWE5O8F5MumUEiIHOn77OKfvnsbS1JIe5XsYOpxs8V7x99jUdRPtVrVj4/mNdP2jK6s6rpKOKSGEEDmColU4FXAKeH2C81eZWZvh28+Xw7MOc+yHY9Ip9Y5UKhVubm64uLiQkJBg6HAMJiEhgf3791OvXj2Z6mVk3rZuzMzMZIRUHhD8czDaBC3uNdwpVKWQocPJFNIpJUQOlDxKyr+MP05WTgaOJvs0K9GMjV030m5VO9aHrafbH91Y2XGldEwJIYQwetf+vsaTa0+wsLfAp4NPho6t+mFVDs86zKUdl3h06RH5SuTLoijzDhMTkzz9Bd7ExITExEQsLS2lU8rISN2ItGgSNBxfeByAqkOrGjiazCMTiIXIYWJexLDyzEoABlYaaOBosl/zEs3Z0GUD5ibm/BH2Bz3W9yBRm2josIQQQojXSk5wXrZLWcysM/ZFM1+JfJRoXgKAYwuOZXZoQgghcoDwTeFE34rGxsWGMv5lDB1OppFOKSFymNVnVhPzIoaS+UpSr0g9Q4djEC1LtuSPzn9gpjZj7bm19NrQi/jEeP6+/jf7H+/n7+t/o9FqDB2mEEIIAUB8VDzn1p0DMjZ172XJd8VDFoeQEJt3p50JIURedXT+UQAqD66MqUXumfQmnVJC5DC/nPwFgIGVB+bpxJStS7XWdUytOrMKp2+ceG/5e8y6Pov3lr+H11wv1oetN3SYQgghBGfXnCXxeSL5vfPjXsP9rcoo0bwEjkUdiXsSR+jK0EyOUAghhDG7G3qX639fR2Wiwu+D3LXyunRKCZGDnLl3hsM3D2OqNqVPxT6GDsfg2ni3YXTN0QA8T3yu99ytqFv4r/GXjikhhBAGFxIQAiSNknrbG0pqEzV+HyZ9ETk2/xiKomRWeEIIIYxc8igpnw4+2Be2N3A0mUs6pYTIQX4JThol1da7LQVtCxo4GsPTaDUsD12e6nMKSY31kTtGylQ+IYQQBvPwwkNuHLiBSq2iYq+K71RWpf6VMLU05U7IHW4euplJEQohhDBmzx8/J/T3pBGy1YZWM3A0mU86pYTIIeIS4/jt9G9A3kxwnpqgiCBuRqXdKFdQuBF1g6CIoGyMSgghhPhP8iipEs1LYFfI7p3Kss5vTbmu5QA49oMkPBdCiLwgJCApl6BLeRc863oaOpxMJ51SQuQQG8I28Oj5IzzsPWhavKmhwzEKkdGRmbqfEEIIkZm0Gi2nlp0C3j7B+auSE56fXXuWmLsxmVKmEEII46RoFd1NiGpDq+XKnMLSKSVEDpGc4Lx/pf6YqE0MHI1xcLNzy9T9hBBCiMx0JfAK0beiscpnRak2pTKlzEJVClG4emG0CVqCfwnOlDKFEEIYp0s7L/H48mMsHS0p36O8ocPJEtIpJUQOcPnRZfZc3YMKFf0r9Td0OEajrmdd3O3dUZH6HQMVKjzsPajrWTebIxNCCCEgZEkIAOV7lM/U5burfpw0WurEwhNoE7WZVq4QQgjjcnReUoJz3/6+mNuYGziarCGdUkLkAL+e/BWAZiWa4emQ++YRvy0TtQlzm88FSLVjSkFhTvM5MrJMCCFEtnv+6DnnN54HMm/qXrKyncpiXcCaqJtRhG8Oz9SyhRBCGIdHlx5xafslUEHVD6saOpwsI51SQhi5BE0CS0KWADCo8iADR2N8Ovh0YF3ndRS2L5ziORUqShcobYCohBBC5HWhK0PRvNBQsEJBXH1dM7VsU0tTKg2sBEjCcyGEyK2O/Zj0+V6yRUnylchn4GiyjnRKCWHktl3cxp2YO7jYuNC6VGtDh2OUOvh04NqIawT2CGR0kdEE9gikvXd7FBQ+2/2ZocMTQgiRByVP3fPt55sliWn9PvBDpVZxdc9V7ofdz/TyhRBCGM6LZy84ufgk8N8CF7mVdEqJLKXRath3bR8rQ1ey79o+NFqNoUPKcZITnPep2Adzk9w5jzgzmKhNqF+kPvWc6lG/SH2mN5mOWqVmU/gmDkQcMHR4Qggh8pC7oXeJPBGJ2lSdZYlpHYs46pKnJ99NF0IIkTuELg8l/mk8TsWdKNGshKHDyVLSKSWyzPqw9XjN9aLh0oZ0X9+dhksb4jXXi/Vh6w0dWo5xM+om2y5uA2Bg5YEGjiZnKV2gNAMqDQBg7K6xKIpi4IiEEELkFcmjpEq1KYWNs02WnSc54fmppaeIj47PsvMIIYTIPoqicHR+UoLzqh9XRaXO/NG2xkQ6pUSWWB+2Hv81/tyMuqm3/VbULfzX+EvHVDoFhASgVbTUK1KPUvkzZynpvGRi/YlYmVpx4MYBtlzYYuhwhBBC5AGaBA2nfz8NZH6C81cVa1yM/KXy8yL6Bad/O52l5xJCCJE9ru+/zr3Qe5hZm1GpXyVDh5PlpFNKZDqNVsOIHSNQSDkyJXnbyB0jZSrfG2gVrW7VPUlw/nYK2xdmRPURAIzbPU7ec0IIIbLcxa0Xib0fi01BG0q2KJml51KpVfh95AckJTyXUcFCCJHzHZufNCW7Qq8KWDpaGjiarCedUiLTBUUEpRgh9TIFhRtRNwiKCMrGqHKe3Vd2c+3JNRwtHeno09HQ4eRYY+uMxcnSiXP3z7Hs1DJDhyOEECKXS566V6FXBdSmWd/U9u3ji5mNGffP3ef639ez/HxCCCGyTtTNKMI2hAH/TdHO7aRTSmS6yOjITN0vr/o5+GcAepbviZWZlYGjybkcLR35vO7nAEzYN4HnCc8NHJEQQojcKuZuDBe2XgDItikXlo6WVOhZAUgaLSWEECLnOv7TcRSNQpH6RShYvqChw8kWRtEp9cMPP+Dl5YWlpSXVq1fn6NGjae4bEBCASqXS+7G0/G9IW0JCAmPHjqV8+fLY2NhQqFAhevfuze3bt/XKefToET169MDe3h5HR0cGDBhATExMlr3GvMTNzi1T98uL7j+7z8bzGwFJcJ4ZPq72MR72HtyMuskPx34wdDhCCCFyqdDloSgahcLVCuNcxjnbzpt8Nz1sQxhRt6Ky7bxCCCEyT2J8IsGLggGoNrSagaPJPgbvlFq9ejWjR49m4sSJBAcHU7FiRZo1a8a9e/fSPMbe3p7IyEjdz/Xr/w1Vjo2NJTg4mC+//JLg4GDWr19PeHg4bdu21SujR48enD17lsDAQLZs2cL+/fsZPHhwlr3OvKSuZ13c7d1fu4+HvQd1PetmU0Q5z7JTy0jQJuBXyI+KrhUNHU6OZ2lqydSGUwGYFjSNx88fGzgiIYQQuY2iKLqpe1md4PxVBcsXxLOuJ4pG4cRPJ7L13EIIITLHuXXneHbvGXaF7fBu523ocLKNwTulZs2axaBBg+jXrx9lypRh4cKFWFtbs3jx4jSPUalUuLq66n4KFvxvWJuDgwOBgYF07twZb29vatSowfz58zlx4gQREREAhIWFsWPHDn755ReqV69OnTp1mDdvHqtWrUoxokpknInahLnN5752n8/qfoaJ2iSbIspZFEXhl5O/AJLgPDP1rNCTci7leBz3mG8OfGPocIQQQuQykSciuXfmHqaWppTrWi7bz588WurEohNoXsjCHkIIkdMcnZc0Y8zvQz9MzPLOd2XTjB7g5eVF//796du3L56enu908hcvXnDixAnGjx+v26ZWq2nSpAmHDh1K87iYmBiKFCmCVqulcuXKTJs2jbJly6a5/9OnT1GpVDg6OgJw6NAhHB0d8fPz0+3TpEkT1Go1R44c4f33309RRnx8PPHx8brHUVFJQ6MTEhJISEhI92tOj+TyMrvc7OTr4osKVYoV+MzV5rzQvmDxycX0KtcLcxNzA0X49rK6fg7eOMj5B+exNrOmo3fHHP0+yG5vqpup9afy/tr3mXtkLkMqDXnjiD6RuXLDZ1tuJvWTfnKNRGpOLjkJQOn3SxtktSSf932wdbMlJjKGsPVhBukYE0II8XZuHbvFrSO3MDE3ocqgKoYOJ1tluFNq5MiRBAQEMGXKFBo2bMiAAQN4//33sbCwyPDJHzx4gEaj0RvpBFCwYEHOnz+f6jHe3t4sXryYChUq8PTpU2bOnEmtWrU4e/Ys7u4pv2DGxcUxduxYunXrhr29PQB37tzBxcVFbz9TU1Py5cvHnTt3Uj3v9OnTmTx5cortf/31F9bW1ul6vRkVGBiYJeVmh5WRK1FQKGtTlq6uXXmc+BgnUycKmBVgzMUxHLt9jK6/dmWge87Nl5RV9TP3etIos5p2Nfln9z9Zco7cLs26UaCMTRnOPTvH4BWDGeo5NHsDE0DO/mzLC6R+3iw2NtbQIQgjkxiXyJkVZ4Dsn7qXzMTchCqDq/D35L859sMx6ZQSQogcJHmhirKdy2LjYmPgaLLXW3VKjRw5kuDgYAICAhg2bBgfffQR3bt3p3///lSuXDkr4tSpWbMmNWvW1D2uVasWPj4+/PTTT0ydOlVv34SEBDp37oyiKCxYsOCdzjt+/HhGjx6texwVFYWHhwdNmzbVdXZlloSEBAIDA3nvvfcwMzPL1LKzQ6I2kaE/JH3ZH9tkLF3LdtV73uWCCx3XdWTLgy30qteL90unHJlmzLKyfp7GPaXb990AmNh6IjXca2Rq+bldeuom/8381FtWjz2P9/Cd/3f4FPDJ5ijzrpz+2ZbbSf2kX/JoaSGSnd90nrgncdh72FO0UVGDxVFlcBWCvgoi4p8I7py6g2tFV4PFkptoNVoigiKIjozGzs0Oz7qeqE0MngVFCJFLPLv/jDOrkm5sVB1a1cDRZL8Md0olq1y5MpUrV+a7777jxx9/ZOzYsSxYsIDy5cszfPhw+vXrh0qlem0ZBQoUwMTEhLt37+ptv3v3Lq6u6fsjamZmRqVKlbh06ZLe9uQOqevXr7Nnzx69jiNXV9cUidQTExN59OhRmue1sLBIdTSYmZlZljXes7LsrLQjfAc3o2+S3yo/nct1xsxU/zV0KNuB/936H98d+o7BWwfj5+5HMadiBor27WVF/awNWcvzxOeUdS5LHa86b/wdEql7Xd3ULVqX9qXbs/H8Ribun8iGLhuyOTqRUz/b8gqpnzeT6yNelZzgvGLvigbtrLArZEfp90tzbu05jv1wjDaL2hgsltwibH0YO0bsIOrmf53R9u72NJ/bHJ8OcmNLCPHuTv56Ek28hkJ+hShcrbChw8l2b/1XMyEhgTVr1tC2bVv+97//4efnxy+//ELHjh357LPP6NGjxxvLMDc3p0qVKuzevVu3TavVsnv3br3RUK+j0WgIDQ3Fzc1NL7bOnTtz8eJFdu3aRf78+fWOqVmzJk+ePOHEif9WJ9mzZw9arZbq1aun67wibT+d+AmAvr59sTBNfVrn9MbTqelek6fxT+m8tjPxifGp7pfXJCc4H1h5oHRIZaFpjaahVqnZeH4jB28cNHQ4QgghcrCom1Fc/usyAL59fQ0bDP8lPA9dHkrckzgDR5Ozha0PY43/Gr0OKYCoW1Gs8V9D2PowA0UmhMgttIlajv2YNHWv6tCqefI7YIY7pYKDgxk2bBhubm4MHTqUsmXLcubMGf755x/69evHl19+ya5du9iwIX2jD0aPHs3PP//M0qVLCQsL48MPP+TZs2f069cPgN69e+slQp8yZQp//fUXV65cITg4mJ49e3L9+nUGDkzKTZSQkIC/vz/Hjx9n+fLlaDQa7ty5w507d3jx4gUAPj4+NG/enEGDBnH06FEOHDjA0KFD6dq1K4UKFcroJREviXgawfZL2wEYXGVwmvuZmZix2n81+azycSLyBGP+GpNdIRqt4MhggiODMTcxp1eFXoYOJ1fzcfahv29/AMbuGouiKG84QgghhEjdqWWnQAHPup7kK5HP0OFQpF4RXMq5kBCbQEhAiKHDybG0Gi07RuyA1JoI/27bMXIHWo02W+MSQuQu4X+GE3UjCusC1pTrkjdzAWa4U6pq1apcvHiRBQsWcOvWLWbOnEnp0qX19ilatChdu3ZNowR9Xbp0YebMmUyYMAFfX19CQkLYsWOHLvl5REQEkZGRuv0fP37MoEGD8PHxoWXLlkRFRXHw4EHKlCkDwK1bt9i8eTM3b97E19cXNzc33c/Bg/+NiFi+fDmlS5emcePGtGzZkjp16rBo0aKMXg7xil+Df0WraGno1ZBS+Uu9dl8PBw+WtV8GwPxj81l7dm12hGi0fglOGiXVwacD+a3zv2Fv8a4mNZiEpakl/0T8w9aLWw0djhBCvLMffvgBLy8vLC0tqV69OkePHk1z34CAAFQqld6PpaX+inGTJk2idOnS2NjY4OTkRJMmTThy5EhWv4wcRVEU3dQ9QyU4f5VKpdKNljr24zEUrdx4eRsRQREpRkjpUSDqRhQRQRHZF5QQItc5Nj9plFTlQZUxtXzr7Eo5WoZf9ZUrVyhSpMhr97GxsWHJkiXpLnPo0KEMHZr6Klj79u3Tezx79mxmz56dZlleXl7pGvWQL18+VqxYke4YxZslahP59eSvwOtHSb2sValWfFrrU2YcnMGAzQOo5FaJEvlKZGWYRunZi2csD10OwMBKOXdFwpyksH1hRlQfwTcHvmHcrnG0KNECE7WJocMSQoi3snr1akaPHs3ChQupXr06c+bMoVmzZoSHh6dYcTiZvb094eHhusevThkoVaoU8+fPp1ixYjx//pzZs2fTtGlTLl26hLOzc5a+npzixoEbPLr0CDMbM8p2KmvocHQq9KzArrG7eHTxEVd2XaF40+KGDinHiY6MztT9hBDiVffP3efqnquo1Cr8PvAzdDgGk+GRUvfu3Uv1LtmRI0c4fvx4pgQlcqZtF7dxK/oWBawLZGhFvf9r9H/U9qhN9ItoOq3tRFxi3st/sO7cOqLioyjmVIyGRRsaOpw8Y2ztsThZOnH2/ll+O/2bocMRQoi3NmvWLAYNGkS/fv0oU6YMCxcuxNramsWLF6d5jEqlwtXVVfeTPEo9Wffu3WnSpAnFihWjbNmyzJo1i6ioKE6fPp3VLyfHOLnkJABlO5XF3NbcwNH8x9zWnIp9KgL/LTMuMsbOzS5T9xNCiFcd/SFpRLN3O28cPB0MHI3hZHik1Mcff8ynn36aIiH4rVu3+Oabb2RYdx6mS3BeMe0E56kxMzFjlf8qKv1UiZA7IYzaMYoFrRdkVZhGKTnB+YBKA1CrZInh7OJk5cRndT/jk8BPmLB3Al3LdcXS1PLNBwohhBF58eIFJ06c0MvBqVaradKkCYcOHUrzuJiYGIoUKYJWq6Vy5cpMmzaNsmVTH+3z4sULFi1ahIODAxUrVkyzzPj4eOLj/1u8JCoqafpTQkICCQkJGX1pr5VcXmaXm14vnr3g3JpzAJTrVc5gcaTFd5AvR+cdJfzPcO5fvI+jl2O2nt/Q9fOu3Gq4YZXPiuePnqe5j4m5CdaFrHPka8zp9ZObSd0Yt8yqn7incZxaegqAyh9UzpX1nd7XlOFOqXPnzlG5cuUU2ytVqsS5c+cyWpzIJSKeRrD94psTnKfF3d6d397/jRbLW7DwxELqe9Wna7n05SXL6cLuh/FPxD+YqEzo69vX0OHkOUOrDeX7I99zI+oGPxz9gf/V+p+hQxJCvCONVkNQRBCR0ZG42blR17Nurp6e++DBAzQaTYqRTgULFuT8+fOpHuPt7c3ixYupUKECT58+ZebMmdSqVYuzZ8/i7u6u22/Lli107dqV2NhY3NzcCAwMpECBAmnGMn36dCZPnpxi+19//YW1tfVbvsLXCwwMzJJy3+TR3ke8iHmBuas5oVGhnNl2xiBxvI5tRVtiTsWwbtw6CvU2zGI+hqqfd5XwJIH4569fHVrzQsMiv0V4jvDEwS9njnLIqfWTF0jdGLd3rZ/7W+6T8CwBSw9Lzsae5dy23NeXEhsbm679MtwpZWFhwd27dylWrJje9sjISExN82ZiLpGUpFtBoVHRRpTMX/Ktymheojmf1fmMaf9MY9Cfg6jsVvmNydJzg+Q8XK1KtaKQnaz+mN0sTS2Z3GAy/Tf356ugrxhQeQCOlo6GDksI8ZbWh61nxI4R3Iy6qdvmbu/O3OZz6eDTwYCRvd6LFy+4evUqxYsXz5b2VM2aNalZs6buca1atfDx8eGnn35i6tSpuu0NGzYkJCSEBw8e8PPPP9O5c2eOHDmSZp6q8ePHM3r0aN3jqKgoPDw8aNq0Kfb29pn6GhISEggMDOS9997DzMwsU8tOj99n/w5AjQ9qUKdVnWw/f3qEJ4TzR6c/iP47mqYBTbM1ia6h6+ddKIrC+i7r0T7XYu9hj6JViL71X+4oe3d7ao6tyemA00SeiOTq/12l5pia1J9SH7VpzhjxnpPrJ7eTujFumVE/ilbhp0+SZhnV/7Q+VVpVycwQjUbyaOk3yfBfpqZNmzJ+/Hg2bdqEg0PSHYEnT57w2Wef8d5772W0OJEL6CU4r5zxUVIvm9xwMgduHODv63/TaW0nDg84jJWZVWaEaZTiE+NZemopAIMqDzJwNHlX74q9+e7Qd5y9f5Zv/vmG6U2mGzokIcRbWB+2Hv81/iivrOF+K+oW/mv8Wdd5ndF1TMXGxjJs2DCWLk36W3DhwgWKFSvGsGHDKFy4MOPGjXtjGQUKFMDExIS7d+/qbb979y6urq7pisPMzIxKlSpx6dIlve02NjaUKFGCEiVKUKNGDUqWLMmvv/6qN1XwZRYWFlhYpJzCb2ZmlmVfrrKy7LQ8vvKYiL8jQAWV+1c22i+OZdqXIdAjkKgbUVzYcIGKvdOeeplVDFE/7+r08tOEbwxHbaqm2+ZuuJR3ISIogujIaOzc7PCs64naRI3fID8CPwnk6LyjHJp5iFuHb9FxVUfsC2duB2xWyon1k1dI3Ri3d6mfy39d5tHFR1jYW1C5r/H+DXlX6X1dGe7KnzlzJjdu3KBIkSI0bNiQhg0bUrRoUe7cucN3332X4UBFzrf1wlZuR9/G2dqZ933Sn+A8NaZqU1Z0XIGztTOn755mxI4RmRSlcdocvpkHsQ8oZFeI5iWaGzqcPMtEbcL0xkkdUXOOzOFW1C0DRySEyCiNVsOIHSNSdEgBum0jd4xEo9Vkd2ivNX78eE6dOsW+ffuwtPwvp12TJk1YvXp1usowNzenSpUq7N69W7dNq9Wye/duvdFQr6PRaAgNDcXNze21+2m1Wr2cUXlVyNIQAIo1KYaDh/FO21KbqnUrOknC8/SJuhXF9qFJKSnqTaiHq68rahS8uEZ5zuDFNdT/fqaYWpjS4vsW+K/xx9zOnIh/IvjJ9ycu7bz0ulMIIfK4o/OTEpxX7FvRqBbJMJQMd0oVLlyY06dPM2PGDMqUKUOVKlWYO3cuoaGheHh4ZEWMwsgtCl4EQF/fvpibvPsvVSG7QizvsBwVKn4O/pnlp5e/c5nG6ufgnwHo79sfU7VMfzWk1qVaU8ezDnGJcUz+O2U+FCGEcQuKCNKbsvcqBYUbUTcIigjKxqjebOPGjcyfP586deqgUql028uWLcvly5fTXc7o0aP5+eefWbp0KWFhYXz44Yc8e/aMfv36AdC7d2+90U1Tpkzhr7/+4sqVKwQHB9OzZ0+uX7/OwIEDAXj27BmfffYZhw8f5vr165w4cYL+/ftz69YtOnXqlEmvPmdStIouOa1vP1/DBpMOlQdWxsTchFtHb3HrmNx0eR1FUfhz0J/EPYmjkF8h6oyrA+vXg5cXNGwI3bsn/evllbT9X2U7lWVI8BBcfV2JfRDL8hbL2fPlHrQarcFeS16h1Wi5tu8aoStDubbvmlxzYfQeX33MhS0XAKj6UVUDR2Mc3upbsI2NDYMHv9s0LZE7XH9yXZfgPDOnn71X/D2+qPcFU/dPZciWIVQpVIXSBUpnWvnG4OrjqwReSUqQ179SfwNHI1QqFd80+Ybai2vz68lfGV1zdK57zwmRW2kVLVsubEnXvpHRkVkcTcbcv38/1fxMz5490+ukepMuXbpw//59JkyYwJ07d/D19WXHjh265OcRERGo1f/di3z8+DGDBg3izp07ODk5UaVKFQ4ePEiZMmUAMDEx4fz58yxdupQHDx6QP39+qlatSlBQUJor9OUVV/de5en1p1g4WFC6vfH/nbBxsaFs57Kc/v00x344RuGAwoYOyWid/PUkl7ZfwsTChPZL22Py5ybw9wfllRGYt24lbV+3DjokTQnOVyIfAw4NYMeoHZxYeIKg/wvixj836LCiA3ZudgZ4Nblf2PowdozYQdTN//LW2Lvb03xuc3w6+BgwMiHSdnzBcVCgeNPiFPBOe+GQvOStM/GdO3eOHTt2sHnzZr0fkbdkRoLztEysP5GGXg15lvCMTms7EZuQvuz9OcXik4sBaFKsCUWdiho4GgFQy6MW7bzboVW0fLb7M0OHI4R4g7jEOH4+8TNlfijDd4fSl0LAze7109Oym5+fH1u3btU9Tu6I+uWXX9I99S7Z0KFDuX79OvHx8Rw5coTq1avrntu3bx8BAQG6x7Nnz9bte+fOHbZu3UqlSpV0z1taWrJ+/Xpu3bpFfHw8t2/fZtOmTVStKnd1Q5aEAFCuWznMrHJGHpCqHyfV25lVZ4h9kLvaU5nlybUn7By1E4BG/9cIZ+98MGJEyg4p+G/byJGg+W9KsKmlKa0XtKbDig6Y25pzbd81fqr0E1f3XM2GV5C3hK0PY43/Gr0OKUiafrnGfw1h68MMFJkQaUuITSD4l2AAqg6Vv6fJMjxS6sqVK7z//vuEhoaiUqlQ/v1QTm5EaTTGlatBZJ2XE5wPqTIk08s3UZuwouMKfBf6cubeGYZtG8av7X7N9PMYQqI2kSUhSwBJcG5spjWexp8X/mTD+Q0cunGImh4Z+1IohMh695/d58djP/LDsR+4H3sfADvzpJEIMS9iUs0rpUKFu707dT3rZmusbzJt2jRatGjBuXPnSExMZO7cuZw7d46DBw/y999/Gzo88Yq4p3GE/ZH0Zde3r69hg8mAwtUL41bZjcjgSE4uPkntT2sbOiSjomgVNvXfxIuYF3jU9qDGqBoQtB9upj0lGEWBGzcgKAgaNNB7qny38rhVdmNtp7XcC73HsibLqD+xPvW+qIfaJGeszmfMtBotO0bsIJWP+qRtKtgxcgfe7bzlegujEroylLjHcTgWdaRky8wd0JGTZfi3dMSIERQtWpR79+5hbW3N2bNn2b9/P35+fuzbty8LQhTGasuFLUTGROJs7Uz70u2z5Byutq6s6LgCtUrN4pDFLDu1LEvOk912XtrJrehb5LfKTzvvdoYOR7ykjHMZ+vkm5WAZu2usruNdCGF4Fx5e4IMtH+A5x5NJf0/ifux9PB08md1sNrdG3yKgfQCQ1AH1suTHc5rPwURtkt1hv1adOnU4deoUiYmJlC9fnr/++gsXFxcOHTpElSq5c4nonOzs6rMkxiVSwKcAhavlnGlwKpVKN1rq+ILjknfnFUd/OMq1vdcwszajfUD7pI6MyHRO9U1jvwLeBRh4eCCVBlQCBf6e9DfLmy8n5m5MJkaeN0UERaQYIaVHgagbUUQERWRfUEK8gaIoHJuftOBE1Y+qSofpSzJ8JQ4dOsSUKVMoUKAAarUatVpNnTp1mD59OsOHD8+KGIWRWnQiKcF5P99+mZLgPC2NijZiYv2JAHy49UPO3T+XZefKLskJzvtU7IOFacqls4VhTWowCUtTS4Iigth2cZuhwxEiT1MUhaDrQbRf1Z7S80vz04mfiEuMw6+QH6s6ruLy8MuMrDESOws7Ovh0YF3ndRS21+8scLd3Z13ndXTw6WCgV5G6hIQE+vfvj0ql4ueff+bo0aOcO3eO33//nfLlyxs6PJGK5Kl7vv18M5TzyxiU61oOSydLnlx7wqXtsjpcsocXHrJr7C4AmsxoQr4S+ZKeeMNKlDqvWfLczNqMtr+0pf3S9phZm3Fl1xV+qvQT1/6+9o5R5233ztxL137RkdFZHIkQ6Xfj4A3uhNzB1NKUSv0rvfmAPCTDnVIajQY7u6Qh8gUKFOD27dsAFClShPDw8MyNThita0+usePSDgAGVcn66Wef1/2cJsWaEJsQS6e1nXj24lmWnzOrREZH6hLyDqw80MDRiNS427szvFpSJ/u43eOMbgl5IfKCRG0ia86uocavNagXUI9N4ZtQUGhTqg1/9/2bowOP0qVclxQrl3bw6cC1EdfY22cvKzqsYG+fvVwdcdXoOqQAzMzM+OOPPwwdhkin+2H3uXn4JioTFRV7VTR0OBlmZm2WNGqH/5Yjz+u0Gi0b+24k8XkiRRsXpeqHL+V4qVsXHB3fXEjv3jBlCjxLu21asXdFBh0bhHMZZ2IiY1jWaBlB04JQtDIaOyNiH8by15i/2Dl6Z7r2lwTzwpgkj5Iq36M8VvmsDByNcclwp1S5cuU4dSppGdzq1aszY8YMDhw4wJQpUyhWrFimByiMU3KC88ZFG1MiX4ksP5+J2oTlHZbjZuvGufvn+GjbRzl2WlVASAAaRUNtj9r4OMvKIMZqXJ1xOFo6cubeGX4//buhwxEiz4iOj2bu4bmUnFeSLuu6cPTWUSxMLBhceTBhH4exudtm6hWp99pRKiZqExp4NaBb+W408GpgdFP2Xta+fXs2btxo6DBEOoQEhABQskVJbF1tDRvMW6r6YVVQweWdl3l48aGhwzG4Q98d4uahm5jbmdNucTtU6pc+Vy5ehNg0ksInf/6UKgXPn8PEieDtDcuWgTb1qZHOZZwZeHQgFXtXRNEq7Pl8DytarZDE8+nwIuYF+/9vP98X+55D3x1Cm6DFxPz1n+sqtQqr/PLFXxiH6NvRnFuXNNsneSq1+E+GO6W++OILtP9+2E6ZMoWrV69St25dtm3bxvfff5/pAQrjk6BJ0K0clxUJztPiYuPCyo4rUavULDu1TJcoPCfRKlpdcngZJWXcnKyc+KxO0gp8X+79krjEOANHJETudivqFuN2jcNzjicjd47k2pNrFLAuwMT6E4kYFcFPbX6idIHShg4z05UsWZIpU6bg7+/P9OnT+f777/V+hHHQJmo5vew0kDR1L6dyKuZEyRZJyXWPLzhu4GgM696Ze+z9ci8Azec0x8HT4b8nX7yAHj2S/q1QAdzd9Q92d4c//oDz52H1avDyglu3oE8fqFoV0siza25jTruAdrT9tS2mlqZc2nGJnyr9RMQByX2UGs0LDUfnH+X74t+z98u9xEfF4+rrSvdt3emwogOogFfvT/z7WNEqLG24lNsnbmd32EKkcGLRCbSJWjxqe+BWybhWATYGGV59r1mzZrr/lyhRgvPnz/Po0SOcnJxy3Nx68XaSE5y72LjQrnT2Jumu71WfKQ2m8MXeL/h428dULVSV8gVzTt6Nfdf2cfnxZewt7OlUppOhwxFvMLTaUL4/+j03om7w47EfGV1ztKFDEiLXOX33NN8d+o6VoStJ0CYAUDJfSf5X83/0rtgbK7Pcfaf7119/xdHRkRMnTnDixAm951QqleTrNBKXdl4i5k4M1gWsKdW6lKHDeSdVP67KxW0XCVkSQqP/a4SZddo5kXIrTYKGjX02onmhoWSrkik7GidNguBgyJcPtm+HggWTVtmLjEzKNVW3Lpj8O1Knc2do2xbmzYP/+7+k4xo2hPbtYcYMKKm/wpZKpaJS/0oU8ivE2k5reXjhIQH1A2g8vTG1/ldLf7RWHqXVaAldEcq+Cft4cu0JAE7FnWj0f40o27ms7hp1XteZHSN26CU9t3e3p+HUhhybf4zbx2+ztOFSum/pTpF6RQzxUoRA80LDiZ+S/r5XG1bNwNEYpwx1SiUkJGBlZUVISAjlypXTbc+XL1+mByaM16Lg7ElwnpbxdccTFBHEzss76bS2E8cHH8fWPGcMo/8l+BcAupfrjo25jYGjEW9iZWbF5AaTGbB5AF8FfUX/Sv1xtHQ0dFhC5HiKohB4JZCZB2cSeCVQt72uZ13G1BpD61KtUavyxqo0V69eNXQIIh2SE5yX71H+jdOGjF2J5iVwKubE4yuPCV0RSuWBlQ0dUrYLmhZEZHAklk6WtPm5jf6N9aAg+PrrpP8vWgSFCiX9v0GDtAu0tIRPPoG+fWHyZFi4EDZuhC1b4OOPYcKEpA6ulxSsUJBBxwexZcgWzqw8w65PdxGxP4L2S9vn2XwziqJw4c8L7Pl8jy6Zua2rLfUn1qfSgEqYmOn/7vl08MG7nTcRQRFER0Zj52aHZ11P1CZqfN73YWXblVz/+zq/N/udzn90pmTLkqmdVogsFbY+jJg7Mdi6KPeY4QAAgN1JREFU2eLzvqRuSU2GWnxmZmZ4enqi0UjS37zq2pNr7LyUlFxwUOWsT3CeGrVKzW/v/0Zhu8KEPwzngy0f5Ij8Ug9jH/JHWFJCW5m6l3P0rtibMs5lePT8ETMOzDB0OELkaC80L1gaspSKCyvS7PdmBF4JRK1S07lsZ44MPML+fvtp6902z3RIvUpRlBzx9yyviX0YS/jmpMV8cvLUvWQqtQq/j/yApITnee09FxkcSdD/BQHQ8oeW+smwnz6FXr1AUaBfP+jYMWOFOzvD/PkQGgqtWkFiIsydCyVKwJw5SdMBX2JhZ0GH5R1otbAVJhYmXNhygZ8q/cTNIzff8VXmPNf3X2dx7cWsareKe2fuYeloSeOvGzP88nD8PvBL0SGVTG2ixquBF+W7lcergRdqk6S/Hxb2FvTY3oOSrUqSGJfIqnarOLvmbHa+JCGA/xaWqDKkSo6/qZFVMtzq+/zzz/nss8949OhRVsQjjFxygvMmxZpQPF9xg8XhbOPMKv9VmKhMWB66XDcCyZj9fvp3XmheUMm1ElUKVTF0OCKdTNWmTG88HYA5h+dwO1pyEwiRUY+fP+brf76m6Nyi9N3Ul9B7odiY2TCi+gguDbvEav/VVCucd4e0L1u2jPLly2NlZYWVlRUVKlTgt99+M3RY4l+hK0LRJmhxreSKa0VXQ4eTKSr1q4SppSl3T93lxsEbhg4n2yTGJ7Kh9wa0iVrK+JehXNdy+jsMHQrXr0OxYkmdSW/LxydplFRgYFJOqsePYdQoKFsWNmxI6vT6l0qlwm+IHwMODSBfiXw8jXjKkrpLODzncJ7oMLwTcoflLZcTUD+Am4duYmplSu1xtRl+ZTh1xtZ5p+mlZlZmdNnQhXJdy6FN1LKu6zqCfwnOxOiFeL3Ik5HcOHADtamaKoPl+19aMtwpNX/+fPbv30+hQoXw9vamcuXKej8i90rQJOiSdGdngvO01PGsw1eNvgJg2PZhnLpzysARpU1RFH45mdRxJqOkcp42pdpQ26M2zxOfM3nfZEOHI0SOcfXxVUZsH4HHbA/G7x7P7ejbFLIrxNeNv+bGqBvMaT6Hok5FDR2mQc2aNYsPP/yQli1bsmbNGtasWUPz5s354IMPmD17tqHDE/w3dS83jJJKZpXPinLdkzpkjv1wzMDRZJ99E/dx/+x9bFxsaPljS/1pe6tWwe+/g1qd9K+dXdoFpVeTJkk5pn75BVxd4dIl6NAhaSrgKznk3Cq5Mej4IMr4l0GboGXnqJ2s6biGuCe5c6GVR5ce8Ue3P/ip0k9c2n4p6Uv7B1UYfmk4TaY3wcopc6YwmpiZ8P7v71NlSBVQ4M9Bf3Lwu4OZUrYQb5I8SqqMfxn9UZlCT4YTnbdv3z4LwhA5wZ8X/uROzB1cbFxo693W0OEA8EntT9gfsZ9tF7fp8kvZW9gbOqwUjtw6wpl7Z7AytaJ7+e6GDkdkkEql4psm31BnSR1+Pfkro2qOypWrgAmRWY7cPMJ3h77jj7A/0CpJK/aWdynPmFpj6Fquq0HyERqrefPmsWDBAnr37q3b1rZtW8qWLcukSZMYNWqUAaMTd07d4c7JO5iYm1C+e85ZWCU9qn1cjZDFIZxbd45ms5thWzBn5Od8WzcO3eDgt0mdEa1/ao2N80u5PSMi4IMPkv7/xRdQs2bmndjEBAYMgC5dkhKfz5wJ+/eDn1/SVMFp03Sr+1k6WOK/xp9jPxxj5+idnN9wnjshd+i0phOF/AplXkwGFH07mr+n/s3JX06iTUz6+1CuWzkaTmlIvhJZk6dYbaKm1YJWWDhYcHDGQQLHBBL/NJ4GkxvIQl0iy8Q+jOXMijMAVB1a1cDRGLcMd0pNnDgxK+IQOcCiE0kJzvv79jeaLxRqlZpl7Zfh+5MvFx9dZPCfg1nZcaXR/YFJnl7YqWwnSZSdQ9X2rE1b77ZsDt/M53s+54/Ofxg6JCGMilbR8mf4n8w8NJN/Iv7RbW9avCljao6hSbEmRvfZbAwiIyOpVatWiu21atUiMjLSABGJlyWPkvJu6411fmvDBpPJ3Cq74V7DnZuHbxL8czD1vqhn6JCyTEJsAhv7bETRKlToVYHS7V+6saTRQJ8+SfmkqldP6pTKCra2MGUKDBoEn38Ov/2W9LNuHYwZA59+Cra2qFQqqg2thnsNd9Z2WsuTq09YXHsxTWc1pepHVXPs5+jzx885MOMAR+YeIfF5IgAlW5ak0VeNcPXN+mmxKpWKJl83wdLRkj2f7WH/1P3EPYmj+ZzmsuKhyBInF58kMS4R10queNTyMHQ4Ri1vZhIVGXb18VX+uvwXAIOqGCbBeVryW+dntf9qTNWmrD67moXHFxo6JD3R8dGsOrMKMFxyeJE5pjWahlqlZn3Yeg7fPGzocIQwCrEJsSw8vpDS80vTfnV7/on4BzO1GX0q9uHUB6fY2XMn7xV/L8d+kcpqJUqUYM2aNSm2r169mpIlZaUoQ9K80BC6PBTIXVP3XpZ89/74wuO6USu50a7xu3h08RF2he1oPre5/pOzZsG+fWBjkzRtz+ztcxili4cHLFsGx45BvXrw/DlMnQolS8KvvyZ1kgGF/AoxOHgwpduXRvNCw/ah21nXZR3xUfFZG18mS4hN4J+v/+H7Yt9z4OsDJD5PxKOWB33/7kv3rd2zpUMqmUqlou74urSY3wKAo/OOsqn/plz93heGodVoOf7jcQCqDa0mbaA3yHCnlFqtxsTEJM0fkTslJzh/r9h7FHMqZuhwUqjlUUuXjHrkzpGcjDxp4Ij+s+rMKp4lPKN0gdLU9qht6HDEOyjrUpa+FfsCMHbX2DyRgFSItNx7do+JeyfiOduTD7d+yMVHF3G0dGRc7XFcG3mNgPYBVChYwdBhGr3JkyczYcIEmjdvztSpU5k6dSrNmzdn8uTJTJkyxdDh5WkXtlwg9kEstm62FG9quMVdslIZ/zJYO1sTfSua85vOGzqcLHF171WOfp+U16Xtr231cxWdPJk0agn+WyUvu/j5JXWGrV8PxYvDnTswcCBUrgy7dgFg5WRF5/WdaTa7GWpTNefWnmNRlUXcCbmTfXG+JU2ChmMLjvF9ie/ZPX43cU/icCnnQtfNXen3Tz+K1CtisNiqfVyN9svaozJRcWrpKdZ1WUdifKLB4hG5z8VtF3ly7UlS/r5u5d58QB6X4U6pDRs2sH79et3P6tWrGTduHG5ubixatCgrYhQGlqBJYHHIYsA4Epyn5X81/0ebUm14oXlBp7WdeBr31NAhAfBz8M8ADKw0UHrJc4FJDSZhYWLB/uv72X5pu6HDESLbnX9wnsF/DsZztidT9k/h4fOHeDl6Mbf5XG6MusH0JtMpZJc7cp9kh44dO3LkyBEKFCjAxo0b2bhxIwUKFODo0aO8//77hg4vT0ueulehVwXUprlzcoGphSmVByUtVJQbE57HR8ezqd8mACoPrkyJZi91Oj1/Dj16QEICtG8P/ftnf4AqFbz/Ppw7B7Nng6MjnD4N770HrVtDWBgqlYoaI2vQL6gfDp4OPLr0iF9q/MKJRSeM8uaYolUIXRnKDz4/sO2jbcRExuDo5cj7v73PkJAheLfxNor2cMVeFem8rjMm5iaErQ9jZZuVvHj2wtBhiVzi2Pykz9NKAyphZpXFoy9zgQz/hW3Xrp3ej7+/P1999RUzZsxg8+bNWRGjMLDN4Zu5E3OHgjYFjSbBeWpUKhUB7QMo4lCEy48v/3979x0WxfU1cPy7SwfBGgUFwVjRqGDXaOy919g7mtiDyU/Nm1iTGEvUGHs3UWMLlmgsiIrGrogVW1SwgQ0FUSm7+/4xgqKigMDswvnk2Sfs7OzM2bku3D1777n0/buv6n+sT4We4tjtY1hoLehWtpuqsYi04ZLdhSGVhwAwctdIdHqdyhGZBp1eh3+wP/vC9+Ef7C/Xzci8r30MBgP+1/1p/mdz3Ge7szBgIdG6aCoVqMTadmu5PPgyQyoPIZtl5i6UnF7Kly/PihUrOHHiBCdOnGDFihV4enqqHVaW9iT0CZe3XQbAs1fmbosK/Sug0Wq4vuc6987fUzucNLVz+E4eBz8mh1sOGkxtkPjB//0PgoKUVfEWLlQSRGqxtIRhw5TV+YYOBXNz2LoVSpeGQYPg3j2cqzjT/2R/ijUrhi5ax5b+W9jQdQMxT4wjkWIwGLi87TLzy83Hp7MP4f+FY5fXjsa/NWbQxUGU6VoGrZlxJXdLtCpB5386Y2FnwVXfq6xosCLTrnYoMs79i/f5b+d/oIEKX1ZQOxyTkGa/GapUqYKfn19aHU4YkQUBLwqce/bGwsy4M725bHKxpt0aLLQWrD+/ntnHZqsaT3yB85YlWpLXLq+qsYi0M7L6SHJY5+DM3TOsPLNS7XCMnk+QD26/ulF/ZX2mBU+j/sr6uP3qhk+Qj9qhCd7dPrG6WP488ycVF1ak1vJabLm0BQ0aWhZvyf5e+znc5zDtS7XHXJvidVPEC//88w87dux4Y/uOHTvYtk1GY6rl1B+nMOgMOFdxJk+JPGqHk66yF8xO8RbFATg2J/OMlrq87TIBCwMAaLmsJVb2Vi8f3LYNZs1Sfl62DPIYSRvnzg0zZsC5c8roLZ0OZs9WphVOmYKNnZaOmzpSb1I9NGYazqw6w4IKCwg7E6Zq2CEHQlhWcxmrmqwi7FQYVg5W1J5QmyH/DaHSoEqYWRpviZeP635MN99uWOew5sbBGyyrtYyou1FqhyVMWPyo02LNipGzUE6VozENaZKUevbsGTNnzqRAgQJpcThhRK6GX31Z4NxEinRXdq7M5PqTAfDe4c3x28dVieNZ7DNWnFkBmM61E8mTyyYXo6qPAuD7Pd/zPE6+VUuKT5AP7da242bEzUTbb0Xcot3adpKYUtm72qft2rbkn5afzj6dOXHnBNbm1nxR/gsuDLrAxo4bqV6wulFMwTB1I0eORKd7c+SgwWBg5MiRKkQkDAZDwtS9zFrg/HXxBc9PLT9lcoW03+ZZ+DP+7vs3AJWHVsatptvLB+/dg169lJ+HDIGGDTM+wPcpVgw2bIA9e8DTEyIilJFd7u5o/lrPp99Uo+fentgXsOfBxQcsqryIk0szvp5q2Jkw/mzxJ0urLyVkfwhmVmZU/boqQ64O4bPvPsMym3Gs1v0+LlWVwut2+ewIOxXG0hpLeRxiHGVAhGmJjowmcFkgAJUGV1I3GBOS4qRUzpw5yZUrV8ItZ86c2Nvbs2TJEqZMmZIeMQoVxY/0aVC4AYVyFlI5muQbWnkorUu0JlYfS4d1HXj0/FGGx+AT5MOj549wze5KvY/rZfj5RfoaXGkwBewLEPI4hLnH5qodjlHS6XUM3T4UA29Oo43fNmz7MJnKp5LktM/9p/fJY5OHcbXGETIshLnN5lIsd7GMDjVTu3z5MiVLlnxje4kSJbhy5YoKEYlbR29xP+g+5jbmlPq8lNrhZIhCdQqRp0QeYp7EcOqPU2qH88G2D9lO5O1IchfLTd2f6r58wGAALy8IC4NSpeDnn9ULMjlq1YLjx5XRXPnzw7Vr0KEDVK9OQYs79D/Zn8INCxP3LI7NvTezsefGDKmLFH4tnA3dNjCv7Dwu/X0JjZmGcl7lGHJlCA2mNMA2t226x5DW8pXJl1C368GlByypvoQHlx6oHZYwMaf/OE1MZAy5i+fm47rGtziYsUpxUmr69OmJbjNnzmTLli0EBwfTooXx1hsSKReri2XJSeMvcP42Go2GJS2X4JbDjWuPrtF7U+8Mry8VX+C8j2cftBrjmkMvPpyNhQ3jao0D4If9PxhNYX1jsj9k/xsjcF5lwMCNiBvsD9mfgVGJeO9rn3gr2qxgdM3RfGT3UQZElfVkz56dq1evvrH9ypUr2NnZqRCRiB8l5d7GHevs1uoGk0E0Gg0VBii1T47NPqZ6Tc4PEbQhiNMrTqPRami1vBUWtq+Unli0CDZtUmo4rVwJNjZJH8hYaLXQowdcugTjxoGtLRw8CFWqYDekL13mfEqdH+ug0SoryS2qtIh7QelTG+xJ2BP+GfwPs4rP4vSK02CAku1LMuDcAJovaI6Ds0O6nDej5C6am17/9iJ3sdxE3IhgaY2lhJ4y/pUOhXEwGAwcnaWs9FlxYEU0WhlNnlwp/qTcs2dPevTokXDr1q0bjRo1ImfO1M2XnD17Nm5ublhbW1O5cmWOHj2a5L7Lli1Do9EkullbJ+4s+Pj40KBBA3Lnzo1GoyEwMPCN49SqVeuN43zxxRepij8z23xxM2FRYThmc6R5seZqh5NiOaxzsLbdWiy0Fmy4sIGZR2Zm2LkvPbiEf7A/Wo2WXp69Muy8ImP18OiBex53Hj57yOQDk9UOx+jcibyTpvuJtJXc6/7w2cN0jiRra9myJcOGDeO///5L2HblyhWGDx8uX/apIPZZLGdXnwWyztS9eGW7l8XCzoL7Qfe5vve62uGkStS9KLb03wJAtf9Vw7mK88sHL19WiokD/PgjlC2b8QF+CDs7GD1aeR29eyuF2VevRlPSnRqR/9Bjc2uyOWbj3vl7LKywME1HvD1//Jzd3+1mZuGZHJt1DH2sno/rf4zXMS/ar21PnuJGUpMrDWR3yU6v/b1w9HAk6m4Uy2st58bBG2qHJUzAtd3XuB90H8tslnj08FA7HJOS4qTU0qVLWbdu3Rvb161bx/Lly1N0rDVr1uDt7c2YMWMICAigbNmyNGzYkLt37yb5HAcHB+7cuZNwCw4OTvR4VFQU1atXZ9KkSe88t5eXV6LjTJ4sHyhfN//EfAB6exh/gfOkVCxQkV8a/ALAN77fcPRW0knPtLQ4YDEAjYs0xtnB+T17C1NlrjVnYt2JAEw/PJ3bkbdVjsi4ONk7JWs/x2yO6RyJeF2MLoYDNw4ka9/ktqNIncmTJ2NnZ0eJEiUoVKgQhQoVokSJEuTOnZupU6eqHV6Wc2HjBaIfR5PdNTuFaptO2YK0YJ3dmjLdygAvC/WaEoPBwNYvtvL03lPyfpKXWmNrvXwwNha6dIGnT6F2bfD2Vi3OD5Y/PyxeDAEBUKcOREfDzz/j2qsuA78y5+PaBYl9GsvG7hvZ3Hczsc9iU32q2GexHJx6kJkfz2T/j/uJjYqlQKUCdPfrTred3chfIX8avjDjYZfXjh57euDyqQvPHz3nj/p/cHXXmyNahXjVsVnK780y3ctg5WD1nr3Fq1KclJo4cSJ53rJCRd68efnpp59SdKxp06bh5eVFr169KFmyJPPmzcPW1pYlS5Yk+RyNRoOjo2PCLV++fIke79atG6NHj6ZevXfX8LG1tU10HAcH0x5umtb+e/gfvld90aChb7m+aofzQQZVGkS7ku0S6kul97f+sbpYlp1aBmDy1068X4viLajmUo1ncc8Y7z9e7XCMiqXWMllTV8fsHaPaggRZjcFgwCfIh1JzSr13dVINGlwcXKhRsEYGRZc1Zc+enYMHD7J161YGDBjA8OHD2bNnD7t37yZHjhxqh5flxE/dK9ujbJacelFpoFKY98LGC0TcjFA5mpQ5++dZgnyC0JprafV7K8ytXlkVdMIEOHYMcuSA5cuVKXGmzsMDdu2CzZuheHG4dw/rEcPoGjaV1l1sQAMnF59kcZXFKa6NpI/TE7AogN+K/obvN748e/iMPO556ODTgT6H+1CoTuZP2FrnsKbrjq4UblCY2KexrGq6iqANQWqHJYzUo+BHXNx8EXj5e1QkX4p/I4eEhFCo0Ju/iFxdXQkJCUn2cWJiYjhx4kSi5JFWq6VevXocOnQoyec9efIEV1dXXFxcaNmyJefOnUvZC3hh5cqV5MmTh08++YRRo0bx9OnTVB0nszLVAudvo9FoWNR8EYVzFib4cTC9NvVK11oJf1/6m7tRd3HM5kjTok3T7TzCOGg0GibVU0ZmLgpYxMX7F1WOyDisOL2COr/XQW/QA0qC41Xx9y20FuwP2U/FhRXp6tOVkMfJ/zsiUuboraPUXFaTtmvbcuXhFfLZ5eOL8l+gefHfq+Lvz2g0AzOt8S7lbcoOHTrEli3KNCONRkODBg3ImzcvU6dOpW3btvTr14/oaNNfBc2UPA55nDAawqOnh7rBqCTvJ3lxremKQWfg+HzT+bIg8nYk/wz6B4DPvv8MJ89XRngeOKBM1wOYPx9cXFSIMJ1oNNC8OZw5A7/9Brlzozl/njIrR/BNOT9cc0UQdjqMBeUXJExLBdDr9AT7BxO+L5xg/2D0OuVvtUFv4Ny6c8wpNYe/vf4m8lYkDi4OtFjSgi9Pf4l7a/csteqqpZ0lHTd3xL2tO7oYHevar+PU76a/EIBIe8fnHcegN1CobiE+Kik1OFPK/P27JJY3b15Onz6Nm5tbou2nTp0id+7cyT7O/fv30el0b4x0ypcvHxcuXHjrc4oXL86SJUsoU6YMjx8/ZurUqVSrVo1z587h7Jz8KVKdO3fG1dWV/Pnzc/r0aUaMGMHFixfx8Ul6afLo6OhEncOICOXbo9jYWGJjUz8s9m3ij5fWx02uGF1MQoHzPh59VIsjLdma2bKq9SpqLK/B5oubmXJgCl9V/ipVx3pf+yw8oRQ471a6G+ghVm/6189UqPXeqexUmaZFm7L18lZG7RrFmrZrMvT8xkSn1/F/e/+PaYenAdC8WHPalmjL/+35P25F3krYr4BDAX6p9wsV81dktP9oVpxZwcozK1l/fj1DKg1hRLUROFjJCNa0EPw4mO/2fMea88q/SxtzG4ZVHsbXVb7G3sqe2q618fb1fmv7NC/SPFP8DUhraXFNxo8fT61atWjWrBkAZ86cwcvLix49euDu7s6UKVPInz8/Y8eO/eBzieQ59fspMIBbLTdyFkpdrdTMoOLAigT7BxOwMICa39fEzNK4E9MGg4G/vf7mefhznMo7UX1U9ZcPRkRAt26g1yv/79BBvUDTk4UFDBoEXbsqCbhff8X2xH56aA9wyakGf9+pyF+d/iJ4XzCun7my6+sd5Lh1Bnue8O+0vWwpUJqyvctx+Z/L3Dmh1Bu0zWNLjf+rQYUvKmBuneKPjJmGuZU57Va342+vvwlcFsjGHhuJjoim0iAZDSMUcc/jCFgYACD/LlIpxb9hOnXqxJAhQ7C3t+ezzz4DwN/fn6FDh9KxY8c0D/BVVatWpWrVqgn3q1Wrhru7O/Pnz2fChAnJPk6/fv0Sfi5dujROTk7UrVuX//77j8KFC7/1ORMnTmTcuHFvbN+5cye2tumz7Kmvr2+6HPd9Dj46yN2nd8lpnhPtFS3//PePKnGkh15OvZh/cz7f+n2LIcRACbsSqT7W29rnXsw9dvy3A4CPH33MP/9knmtnStR47zTQNmAb29hwcQMz1s2gmF2xDI9BbVG6KKYFT+NExAkA2udrTyebTmhDtMz8eCbnn5wnPC6cnOY5KZmtJGZXzTh99TTtzNrhWcyTpbeXcvbJWaYcmsKCYwvo6NiRBrkbYKYx7g9ExipKF8VfYX/x972/iTXEokFDrZy16OLUhTxRedjvp6x6aIVVku3zz1X5HfY2aTG6OjAwMFHfZfXq1VSqVImFC5UvNlxcXBgzZowkpTKIwWAgcFkgkPUKnL+uRKsS2Oe3J/J2JOf/Ok/pTqXVDumdTi45yeV/LmNmZUar5a0ws3jlb8aQIXDtGri5waxZqsWYYXLkgClT4IsvYORINOvXU/yOP4Utj+IfU5XDc2N5Mvd3erGd7Lycnvn4lgPbJzTiDiWxzGZJ1eFVqepdVerivKA119JicQssHSw5OvMo2wZv4/nj59T4tkaWGjkm3u7smrM8e/CM7AWzU6xZ1uv/p4UUJ6UmTJjA9evXqVu3LubmytP1ej3du3dPUU2pPHnyYGZmRlhYWKLtYWFhODomr+ithYUFnp6eXLlyJfkv4C0qV64MKKvdJJWUGjVqFN6vFEWMiIjAxcWFBg0apHk9qtjYWHx9falfvz4WFhlfYPy3Vb8B0L9Sf1rUylwr/zQ2NObhxoesC1rH7LDZHO19lNy2yR/hB+9unwn7J2DAQC3XWvRp3SctQxfJoPZ7J2BLAMtPL2dL9BZ82/lmqY7KlYdXaLOuDRciLmBtbs3Cpgv5vNTnifZpFNvone0zyDCIrVe2MtJvJJceXmL+zfnsfbaXn+v8TJMiTbLU9fwQsbpYFp1cxIT9E7j/7D4AtVxrManuJDwdPZN83vvaR7wUP1r6Q4SHhycaLe7v70/jxo0T7lesWJEbN2TFp4wSsj+E8P/CsbS3xL2tu9rhqMrMwoxy/crhP9afY7OPGXVS6lHwI3Z8pXwZWHtCbfKWyvvywXXrXtaP+uMPyEr1YwsXVl7/v/+Ctzfmx45Rl91U4RC2PHtjdwci6MBafKw70+DyPOwd7VUI2rhptBoazWiETU4b/Mf5s+e7PUQ/jqbepHrSP8nCDAYDR39TFtKq8GUFtOaZoF6dClKclLK0tGTNmjX88MMPBAYGYmNjQ+nSpXF1dU3xccqXL4+fnx+tWrUClOSWn58fgwYNStYxdDodZ86coUmTJil9GYkEBgYC4OSU9ApDVlZWWFm9+W2BhYVFunXe0/PYSbny8Ap+1/3QoKF/xf6Z8oPJopaLCAwL5PLDy/Td2pfNnTYnqxjz615vH51ex/LTygqUXuW9MuW1MxVqvHcAJtSZwOpzq9kXsg+/YD8aF238/idlAn5X/Wi/rj3hz8MpYF+AjR03UiF/hST3f1f7tC7ZmmbFm7EwYCFj9o7h4oOLtF7XmjqF6jC1/lQ8nZJOqmR1BoOBLZe28I3vN1x8oNQ2K5GnBFPqT6Fp0abJ7jSr9f4xJWlxffLly8e1a9dwcXEhJiaGgICARCOyIyMjpR0yUHyB81IdSmFpZ6luMEagfL/y7P9hPzcO3CD0VCiOZY1vlVSD3sDm3puJiYzBpZoLVb1fzqbg5k3o31/5edQoqF797QfJ7KpXh8OH4c8/ifvqG+zu3XnrbhrAANR7voUH5+5KUioJGo2GWmNrYZXdip3eOzk45SDPHz2n6dymaM0kGZEV3Tpyizsn7mBmZUa5vuXUDsdkpfrdU7RoUdq3b0+zZs1SnJCK5+3tzcKFC1m+fDlBQUF8+eWXREVF0atXLwC6d+/OqFGjEvYfP348O3fu5OrVqwQEBNC1a1eCg4Pp2/flCmcPHz4kMDCQ8+fPA3Dx4kUCAwMJDQ0F4L///mPChAmcOHGC69evs3nzZrp3785nn31GmTJlUns5Mo34AucNizTELYebusGkEwcrB9a2X4uVmRVbL29l6sG0WXLb96ovIY9DyGmdkzbubdLkmMK0uGR3YXClwQCM2DUCnV6nckTpy2Aw8NuR32i4oiHhz8OpXKAyx7yOvTMhlRwWZhYMqDiAK4OvMOLTEViZWbH72m7KLyhPz409uRVx6/0HyWIC7gRQ9/e6tFjdgosPLpLHNg+zm8zm9BenaVasmXyLa4SaNGnCyJEj2b9/P6NGjcLW1pYaNV6udHj69OkkR2+LtBXzJIZz65SFc7JqgfPX2TvZJ4wYOzb7mMrRvN2xOce4tvsaFrYWtFre6mVSQK+Hnj0hPBwqVIAxY1SNU3VaLXTpwo3eo9+5mwbITgT6vf4ZE5cJq/pVVZovao5GqyFgYQA+XXzQxWbuPp94u6OzlFFSpTuVxjZP+pT0yQpSnJRq27YtkyZNemP75MmTad++fYqO9fnnnzN16lRGjx6Nh4cHgYGBbN++PWE4e0hICHfuvMzoh4eH4+Xlhbu7O02aNCEiIoKDBw9SsmTJhH02b96Mp6cnTZsqq5517NgRT09P5s2bBygjtHbt2kWDBg0oUaIEw4cPp23btvz9998pvRSZTowuhqWBSwHoX76/ytGkLw9HD2Y2ngnAt37f8m/Ivx98zPiEXrcy3bA2t/7g4wnTNKrGKLJbZefM3TOsOrNK7XDSTYwuhv5b+jNk+xB0Bh3dynRjb8+9ONknPeI0pbJbZ+fnej9zYdAFOn3SCQMGlp9aTtHfijJ6z2iexDxJs3OZqhuPb9B9Q3fKLyjPnut7sDKzYuSnI7ky+AoDKg7AwkxG2hirCRMmYG5uTs2aNVm4cCELFy7E0vLlCJ0lS5bQoEEDFSPMOs6tO0dsVCy5iubC5dNMtDLbB6o4sCIAp1ec5ln4m1O+1PTg8gN2jdgFQL1J9chVJNfLB2fMAD8/sLWFlSuVIuCCbBYxydrPHvnbmhzl+pSj7eq2aC20nFtzjjWt1xD7TBYGyUqehD3h3FrlC42KgyqqHI1pS3FSat++fW+dLte4cWP27duX4gAGDRpEcHAw0dHRHDlyJKG+E8DevXtZtmxZwv3p06cn7BsaGsrWrVvx9Ew8laNnz54YDIY3bvGFQl1cXPD39+fBgwc8f/6cy5cvM3ny5DSvC2WKNl3YxN2ouzhlc6Jp0aZqh5PuvMp50bl0Z3QGHR3Xd+Re1L1UHyvsSRibLm4CoG+5vu/ZW2RmuWxyMaq6MsLz+z3fEx2X+ZZ0vxd1j3q/12NhwEI0aJhSfwrLWy1Pt2SsWw43VrVdxZG+R6hesDrP4p4xYd8EiswswsITCzP9iLS3iYyO5Lvd31FsVjH+OP0HAF1Kd+HioItMrDeR7NbZVY5QvE+ePHnYt28f4eHhhIeH07p160SPr1u3jjFZfYRHBomfuufR00O9UYU6HezdC3/+qfxfp/7vtYLVC5K3dF7insUlFIE3Bnqdnk09NxH7NJZCdQpRccArHwZPn1am6wFMmwbFpOhwvNy1PknT/QSUal+Kjps6Ym5jzuWtl1nZeCXREZmv3yfeLnBxIPpYPc5VnMlfPr/a4Zi0FCelnjx5kuibvHgWFhZpUvhTqGf+ifkA9PHskyW+XddoNMxvNp/iuYtzK/IW3TZ0Q2/Qp+pYv5/6nTh9HJULVKZ0PuMtCCoyxuDKg8lvn5/gx8HMPT5X7XDS1Omw01RcWJH9IftxsHJgS+ctfF3t6wz5IFepQCX29dyHTwcfiuQqQlhUGP229MNjvgfbr2xP9/Mbgzh9HAtOLKDob0X5cf+PPI97To2CNTja9ygr2qzANUfqptML9WTPnh0zszdXmMyVK9db+1sibT288pCQ/SFotBrKdi+rThA+PsrqcLVrQ+fOyv/d3JTtKtJoNAmjpY7POY5Bb1A1nniHph3ixsEbWNpb0mJJCzTaF39/nj+HLl0gJgaaN4dXVtsWoK1Vk9jc+UiqFQ1AbG5HtLVqZmRYJq9o46J03dEVKwcrgv2D+b3u7zy9/+ErtArjZogzcHLhSUBGSaWFFCelSpcuzZo1a97Yvnr16kTT6IRpufLwCn7XlALnWWmkTzbLbKxrvw4bcxt2/LeDn//9OcXHMBgMLDqpTN3zKueV1iEKE2RrYcu4WkrB4h/2/cDj549VjihtbAjaQLXF1Qh+HEyRXEU43OcwTYp+2EITKaXRaGjt3ppzA84xo+EMctnk4uzdszRe2ZiGKxpyJuxMhsaTUQwGA9sub8Njngf9t/QnLCqMIrmK4NPBB/+e/lQsIB0iIVIjfgTQx/U/xsFZhVHzPj7Qrp1SmPtVt24p21VOTJXpUgar7FY8vPKQ/3z/UzUWgLvn7rLnuz0ANJzekByuOV4+OGoUnD0LefPCokUgtfQSMzPDYsEcQPPWxJQGsOjQGt6SJBfv5lrDlR57emCbx5bbx2+zrOYyIm9Hqh2WSAd6nZ5g/2BuLbtF5K1IbD+ypWQ7yYF8qBQnpb7//nsmTJhAjx49WL58OcuXL6d79+788MMPfP/99+kRo8gAC08sBKBRkUZZ7pv20vlKM6vJLECZbuV/PWUFHveH7OfSg0tks8zG5598nh4hChPU06MnJfKU4MGzB0w5OEXtcD6IwWDgh30/0GZtG6Jio6j3cT2O9D2C+0fqLZtuaWbJ0CpDuTL4CsOrDsdCa8HO/3biMd8Dr81e3Il8+wpDpuhU6CkarmhIk1VNOHfvHLlscvFro185N+Acrd1bSxFzIVJJr9NzavkpADx6eWR8ADodDB0KhrekCOK3DRum6lQ+y2yWCcXf1S54rovVsbHHRnQxOoo2KYpn71dKeOzcqdSSAli6VElMiTe1aYPmr/Xg7JxosyFbNuWHefOUOlwixZzKOdFzX0/sC9hz7/w9llRfQvjVcLXDEmkoyCeIX91+ZWX9ldzfch+AuOdxXN56WeXITF+Kk1LNmzdn48aNXLlyhQEDBjB8+HBu3brF7t27KVKkSHrEKNJZVipwnpReHr3oXrY7eoOeTn914m7U3WQ/d2GAktDrWKoj2SyzpVeIwsSYa82ZWHciANMPTzfZJMnT2Kd0/Ksj3+9RvnQYXGkw27psI5dNrvc8M2PktMnJ1AZTuTDoAu1Ltkdv0LPo5CKK/laU8f7jiYqJUjvEVLsdeZs+m/rgOd8T36u+WJpZMrzqcK4MvsKQykOwNJOpXSKx2bNn4+bmhrW1NZUrV+bo0aNJ7rts2TI0Gk2im7X1y7pwsbGxjBgxgtKlS2NnZ0f+/Pnp3r07t2/fzoiXkiGu+V0j4mYE1jmsKdGyRMYHsH//myOkXmUwwI0byn4qiq/ZdGnLJcKvqfch+9+J/3LnxB2sc1rTfGHzlwn5Bw+U1fYABgyAt9S+Fa9o0wbN9evE+fpy3NubOF9fNOHhyrUzGKB7d1i3Tu0oTdJH7h/R+9/e5Cyck0fXHrGk+hLunkv+ZwphvIJ8gljbbi0RNxOXK4p5EsPadmsJ8glSKbLMIcVJKYCmTZty4MABoqKiuHr1Kh06dODrr7+mbFmV5uKLD7LxwkbuPb1Hfvv8NC2W+Qucv41Go2FOkzm453HnzpM7dPXpmqziyeHPwll/fj0AXuVl6p5IrGXxllR1rsrT2KeM9x+vdjgpduPxDWosrcHac2ux0FqwoNkCZjaeibnWXO3Q3vBxzo9Z234tB3ofoIpzFaJioxizdwzFZhVjWeAykyqGHhUTxbi94yj6W1GWBC7BgIEOpToQNDCIqQ2mktMmp9ohCiO0Zs0avL29GTNmDAEBAZQtW5aGDRty927SH4gcHBy4c+dOwi04ODjhsadPnxIQEMD3339PQEAAPj4+XLx4kRYtWmTEy8kQ8VP3Pun8CebWKvxeu5PMLyuSu186yV0sNx/X/xgMcHzecVViuHPyDvsmKAsqNZnVBPv89soDBoNSO+rOHShRAqaY9sjkDGNmhqFmTW599hmGmjXB3Bx++w369AG9Xqlttnmz2lGapBxuOei1vxd5P8nLkztPWPbZMm4du6V2WOID6HV6tg/dzlvnvb7Ytn3YdvS61NUmFqlMSoGyCl+PHj3Inz8/v/zyC3Xq1OHw4cNpGZvIIK8WODfGD5sZxc7SjnXt12FrYYvvVV9+2v/Te5+z6swqnsc9p3Te0lTMLzVdRGIajYaf6yl1yhYGLOTSg0sqR5R8h24couLCigTcCSCPbR78uvuZROK1mks1DvY+yJp2ayiUoxC3I2/Ta1Mvyi8oj99VP7XDeyedXseSk0so+ltRxvqP5WnsU6o6V014PR/n/FjtEIURmzZtGl5eXvTq1YuSJUsyb948bG1tWbJkSZLP0Wg0ODo6Jtzy5cuX8Fj27Nnx9fWlQ4cOFC9enCpVqjBr1ixOnDhBSEhIRrykdPX80XMubLgAgGcvz/fsnU6cnNJ2v3QUX/D85OKTxD2Py9Bzx0XHsbH7RvRxetzbuvNJp1dWh1u2TKm7ZW6uTDuztc3Q2DIVrRbmz1eKxcfFQfv2sGOH2lGZJHsne3r696RApQI8e/iM3+v+znX/62qHJVIpZH/IGyOkEjFAxI0IQvab/t9GtaQoAxEaGsqyZctYvHgxERERdOjQgejoaDZu3ChFzk3U5QeX2X1tNxo09PHso3Y4qiuVtxRzmsyh56aejPUfS/WC1aldqPZb9zUYDAlT97zKeUldF/FWn7l+RrNizdhyaQv/t/v/WNfe+IfELw9cTr8t/YjRxVAmXxk2ddyEWw43tcNKNo1GQ4dSHWhZvCWzjs5iwr4JnAo7Rb0/6tG0aFMm159MyY+M62/Wrqu7GL5zOKfDTgNQKEchJtWbRLuS7eR3i3ivmJgYTpw4wahRoxK2abVa6tWrx6FDh5J83pMnT3B1dUWv11OuXDl++uknSpUqleT+jx8/RqPRkCNHjiT3iY6OJjr65ZLo8Sszx8bGEhsbm4JX9X7xx0vNcU+tPEXc8zg+KvURecrkSfPYkqVKFcydnODOHZJ6lxvMzYmztgY14ntFoYaFcCjoQERIBKdWnqJM9zLvfc6HtM+r9ny/h7tn72L7kS0NZjYgLu5FUuy//zAfMgQNoBs7Fn3p0qpfJ1OSZPssXIjZs2dofXwwtGqFbvNmDLVqZXyAJs7c3pyO2zqyvu16gvcGs7LRStqsbkORJu8vd5NW7x2RNh7deJTs/aTNEkvu9Uh2Uqp58+bs27ePpk2bMmPGDBo1aoSZmRnz5s1LdZBCffFJlcZFG2e5AudJ6eHRA/9gf5YGLqXTX50I/CIQx2yOb+wXEBrAqbBTWJlZ0aVMFxUiFaZiYt2JbL20lfXn13P01lEqFaikdkhvpdPrGLFrBL8c+gWA1iVa83vr3022VpqVuRXDqw2np0dPxvuPZ87xOWy9vJXtV7bjVc6LcbXHkddO3WK45+6e4xvfb9h2ZRsAOaxz8F2N7xhUaRBW5laqxiZMx/3799HpdIlGOgHky5ePCxcuvPU5xYsXZ8mSJZQpU4bHjx8zdepUqlWrxrlz53B+rQgywPPnzxkxYgSdOnXCwSHpVeomTpzIuHHj3ti+c+dObNNpFIuvr2+Kn3PpV2XkqkUlC7Zt25bWISWPwUANe3ty3bmDARIlpuJniWji4tDWqMG53r251rixqivK2dW0I+KPCHZP2s3NPO+ohfWa1LRPvKiLUVz+RSkinLdPXvyPKYvRaHQ6qn/7LbmePOF+qVIccHeHf/5J9Xmysre1j6ZTJyreuIHTsWPQogWHx4zhobt6i5uYsuwDsuMQ5UDEsQjWtl2L6zBXctZI3jT8D3nviLRz//D9ZO13Nvgswf8Ev3/HLOTp06fJ2i/ZSalt27YxZMgQvvzyS4oWLZrqwITxiI6LTihw3q9cP5WjMS6zmszi2O1jnL17ls5/dca3my9m2sRL5C4+uRiAdiXbGU3RZ2GcPsn7CT08erAscBkjdo1gd/fdRjf65fHzx3T8qyPbr2wH4PvPvmdsrbFoName5W00ctvm5tfGvzKo0iBG7BrBhgsbmHdiHivPrGRU9VEMqzIMGwubDI0p7EkYo/eMZtHJRegNesy15gysOJDvP/ue3La5MzQWkTVVrVqVqlWrJtyvVq0a7u7uzJ8/nwkTJiTaNzY2lg4dOmAwGJg7d+47jztq1Ci8vb0T7kdERODi4kKDBg3emcxKjdjYWHx9falfvz4WFhbJft698/cIvByI1lxL+wntsctrl6ZxJZdm8WLML13CYGYGuXPDq/W/nJ3RjR2LdsMGzLZupcyCBXwSFoZuwQLIqU5duaiKUcxaM4unl5/i8ZEH+Svmf+f+qW2fhOc/jWXxN4tBr9T9ajH+ZT0z7Q8/YHbxIobs2cm+cSNNXOWL1ZR6b/s0bIi+bVvMfX2p/tNP6HbswFChQsYHmgnomurY0mcL51afI3haMCULl8Szb9LThj/0vSPShj5Oz8FJBzk1/9S7d9SAQwEH2n/dHq2Z6feb01L8aOn3SXZS6t9//2Xx4sWUL18ed3d3unXrRseOHVMdoFDfxgsbuf/0PgXsC2TZAudJsbWwZV37dVRYUIE91/cw3n8842q//Ob3me4Zqy+uBqBvub5qhSlMyLha4/jzzJ/svb6XHf/toFGRRmqHlODyg8s0/7M5Fx9cxMbchmWtltGhVAe1w0pzRXMXxedzH/YF72P4zuEcv32cb3d/y9zjc/mp7k90Lt053ZNwT2OfMv3QdH4+8DNPYp4A0Ma9DT/X/ZmiueULH5E6efLkwczMjLCwsETbw8LCcHR8c6Tv21hYWODp6cmVK1cSbY9PSAUHB7N79+73JpasrKywsnpzlJ+FhUW6fbhK6bHPrjgLQNGmRclRIEe6xPReFy7Ai+SdZuJE5ef9+5WC3U5OaGrUwNzMDHr3hpkz4Ztv0G7ahDYwEP78E15JKGaUHPlzUOrzUpz+4zQn55/EtVryEkGpbXu/MX48vPwQ+/z2NJnV5OUxDh+GH38EQDNnDhay+vcHSbJ9LCxg40Zo2hTN3r2YN20Ku3eDh0dGh2jyLCwsaLuyLdY5rDkx7wTbBmwj9kksn37z6XufJ0kpddy/cJ8N3Tdw+5iy4myBKgW4deRFwfpXC56/+I650a+NsLKWEe6vS+6/32T3vqtUqcLChQu5c+cO/fv3Z/Xq1eTPnx+9Xo+vry+RkZGpDlaoQwqcv1uJPCWY30y5RhP2TWDX1V0Jjx14dIAnMU8okqsINV1rqhWiMCEFsxdkUKVBAIzYNQK9wThW6PD9z5dKiypx8cFFnB2c+bf3v5kyIfWqz1w/40jfI6xss5KC2QtyI+IG3TZ0o9LCSvhf90+Xc+oNev449QfFZxXnuz3f8STmCRXzV2Rfz3381eEvSUiJD2JpaUn58uXx83tZzF+v1+Pn55doNNS76HQ6zpw5g9MrRbXjE1KXL19m165d5M5t+qP4dLE6Tv+h1G7z6OWhThDR0dCpEzx7BvXqwfDhYGYGtWop22vVUu6DMl1v6FA4eBAKF4bgYKhRAyZNUlZJy2DxBc/PrjnL0/vJm5aRGtf3XufIr0cAaLG4BTY5X4xmffIEunYFnU65Vp07p1sMAqVw/N9/Q7VqEB4O9evDuXNqR2WSNFoNTec05dMRSiJq1/92sfu73RgMb1vSTajFoDdweMZh5nvO5/ax21jnsKb1itb0OdiHDus74FAg8RczDs4OdFjfAfc2Jjq9VaeDvXuVLzv27lXuqyDFXwnb2dnRu3dv/v33X86cOcPw4cP5+eefyZs3b6ZaJjizu/TgEnuu70Gr0dKnnBQ4T0qXMl3o69kXAwa6+HTh5uOb+Af781fYXwD09uhtdNOwhPEaVX0U2a2yczrsNKvOrFI1FoPBwMwjM2m8sjGPnj+iqnNVjnkdo5xTOVXjyihajZbOpTtzYeAFJtadiL2lPSfunKDW8lq0Wt0qTVdK3Ht9LxUXVqT7xu7cjLhJwewFWdlmJYf7HqaGa400O4/I2ry9vVm4cCHLly8nKCiIL7/8kqioKHr16gVA9+7dExVCHz9+PDt37uTq1asEBATQtWtXgoOD6dtXGf0bGxtLu3btOH78OCtXrkSn0xEaGkpoaCgxMTGqvMa0cGX7FaLCorD9yJaiTVRKBo8aBYGBkCcP/P67surZ+1SoAAEB0LGj8qFh5Eho0iTxlL8MUKBSAfJXyI8uWkfA4oB0OUd0ZDSbem0CoJxXOYo0emUk1LBh8N9/4OICc+aky/nFa7JlU+p1VagA9+8ridRLprOasDHRaDTU+7kedSfWBWD/j/vZNmQbBr0kpozBo+uPWF5nOTu+2kHc8zgKNyzMl2e+pEyXMmg0GtzbuDP0+lC6+HbB1duVLr5dGHptqOkmpHx8wM0NatdWEvy1ayv3fXwyPJQPmqdQvHhxJk+ezM2bN/nzzz/TKiaRARaeeFHgvEhjCmYvqHI0xm1m45mUyVeGu1F3KfxbYeqvrM+dmDsA/Hb0N3yCMv6NK0xTbtvcjKw+EoDv93xPdFz0e56RPqLjovH624uh24eiM+joUbYHe3rseWtB/8zOxsKGkdVHcmXIFQZUGICZxoxNFzdRak4phmwbwv2nyStu+TYX7l+g5eqW1F5em4A7AThYOfBz3Z+5OOhihkwVFFnL559/ztSpUxk9ejQeHh4EBgayffv2hOLnISEh3LlzJ2H/8PBwvLy8cHd3p0mTJkRERHDw4MGE1ZRv3brF5s2buXnzJh4eHjg5OSXcDh48qMprTAuBSwMBKNO1DGYWZu/eOT1s3w7Tpys/L1kCr4xMey8HB1i1ChYuBBsb2LEDypZVplRlEI1GkzBa6vjc4+h1aT9aa+fXO3l0/RE53HLQ4JcGLx/YsAEWL1ZGj/3xB7xjFUiRxrJnf/nvLTQU6taFa9fUjspkVR9ZnSZzmoAGjs06xsaeG9HHGccI+qzIYDAQsCiAuaXnEuwfjIWdBU3nNqXLti44OCceGaU10+Ja05Wcn+XEtaar6daQ8vGBdu3g5muLVty6pWzP4MRUmlxFMzMzWrVqxebNm9PicCKdRcdFs+zUMgD6lZcC5+9jY2GDVzkvAGJ0ib8dDn0SSru17SQxJZJtSOUh5LfPz/VH15l3PONXL70bdZe6v9dl8cnFaDVafmnwC0tbLs3yK73ltcvL7KazOfPlGZoXa06cPo7fjv5GkZlFmHJgCs/jnifaX6fXsff63oQ6YTr9y+HO96LuMeifQXwy5xM2X9yMmcaMgRUHcmXwFUZUH4G1uXVGvzyRRQwaNIjg4GCio6M5cuQIlStXTnhs7969LFu2LOH+9OnTE/YNDQ1l69ateHq+LLzr5uaGwWB4662WiS4PH3Uvikt/KyM8VJm6FxYGPXooPw8aBM2bp/wYGg307QvHjkHJkkqCoF49+P57iItL23iTUOrzUtjksuFx8GMu/3M5TY99ZccVAhYoI7BaLGmBlf2Lv023b4OX0hfjf/+DmlI6IcPlygW+vsq/u5s3oU4duHFD7ahMVsUvK9L6j9ZozDSc/uM069qvIy46Dr1OT7B/MOH7wgn2D06XxK94KfJOJH82/5O/vf4m5kkMBasX5ItTX1DhiwqZdzaMTqdMC3/b1NH4bcOGZehUPhNN7YkPseHChoQC502KNlE7HKOn0+uYdGDSWx8zvKh0N2z7sEQfSoVIiq2FLWNrjgWUWmWPnz/OsHMHhgZScWFFDtw4QHar7GztvBXvqt6Z949uKrh/5M7mTpvx6+6Hp6Mnj6Mf879d/8N9tjurz67GYDDgE+SD269u1F5em84+nam9vDZuv7qx+uxqJv07iSK/FWH2sdnoDDqaF2vO2QFnmdVkFh/ZfaT2yxMiSzuz8gz6OD1O5Z3IVzpfxp5cr4devZTpdp98ApMnf9jxSpVSElN9+yofIn74QUkSvP6tdzqwsLHAs4+SwDw261iaHfdZ+DM291G+4K40pBKFahdSHoi/dg8egKcnjB+fZucUKfTRR7BrFxQpAtevK//mXhmBKVKmTJcyfO7zOWZWZlzYeIFFlRYxw3UGK+uvJHhaMCvrr+RXt18J8glSO9RM6eyas8z9ZC6Xt17GzNKM+lPq02NvD3IVzsSrqut0yojTd/2tMBiUhPP+/RkWliSlsqD4Aud9y/WVAufJsD9kPzcjkn7jGjBwI+IG+0My7o0rTFsvz14Uz12cB88eMPXg1Aw551/n/+LTJZ8S8jiEormKcqTvEaNaAdDY1ClUh+P9jrOs5TIK2Bfg+qPrdPqrE8VnFaft2rZv/E64GXGTTn91YqTfSCKiI/B09GR3991s7rSZEnlKqPQqhBDxDAZDwtQ9VUZJ/fYbbNsG1tZKQVkbmw8/pq2tMpXvzz/B3l75AOHhAVu2fPix36PClxVAA//t/I8Hlx6kyTG3D91O5K1IchXNRb2J9V4+MGsW7NypXLuVK8HSMk3OJ1LJyUmZMurmBleuKFP5Mri2WWZSvEVxuvzTBTMrM8JOhxF5K/HiYRG3Iljbbq0kptLQ0wdPWd9xPX91/ItnD5/hVM6JfgH9qPZ1NdOdjpcUvV6pYTh9OrRsqdQy7N8/ec/NwIRzJrvq4n0uPbjE3ut7lQLnnlLgPDnuRCbvDZnc/YQw15ozse5EAKYdnkbok9B0O5feoGfc3nG0W9eOp7FPqf9xfY70PULxPMXT7ZyZhVajpYdHDy4NvsSE2hOwNbfl8sN3T1Ux05ixtOVSjvc7Tu1CtTMoUiHE+4SeDCXsdBhmlmaU7lQ6Y09+6pQy5Qzgl1+UkVJpqWNHpQh6+fLKaKLmzcHbG9KxIH3OQjkp1rQYAMfmfvhoqQsbL3D6j9NotBpaLW+Fhe2LZcTPnXt57aZOBXcTLSic2bi4KIkpZ2cIClJW5Xv4UO2oTJZrTVessycxtf/FbKrtw7bLVL40cGnrJeZ+Mpdza86hMdPw2ejP6HO4D3lL5VU7tLSh1yt/c379FVq1UpJQnp7K34TNm+HRo+R/KZKSmocfSJJSWcyCEwsAaFK0CS7ZXVSOxjQ42SfvDZnc/YQAaFWiFVWcq/A09inj/dNnKkJUTBSfr/+csf5jARhWeRj/dPmHnDY50+V8mZWthS3fffYdf7T547376gw63HK4SRFzIYzMyaUnASjRqgQ2udJglFJyPX2qJI1iYpRk0Zdfps95ihSBAweUOiCgfCv+6afKSnXpJL7geeDSQGKiUp8Ai7oXxZb+yuiuat9Uw6Xqi/5pdLSyIlR0NDRuDAMGfHDMIg0VKqQkphwd4fRpaNAAHmdcSYLMJGR/CFF3o5LewQARNyII2R+ScUFlMtER0Wzuu5k/m/3Jk9An5CmRhz6H+lB7XG11Fr1IK3q98v6bORNat1am2Hp4KH8LNm2C8HBlJG2TJsq08aNHlW3OzkqNwrfRaJTEc42MWyFaes1ZSHRcNMsClwHQr5wUOE+uGgVr4OzgjIa3v3E1aHBxcKFGQVnaXSSfRqPh57o/A0qy+NKDtF1eOeRxCNWXVmf9+fVYaC1Y3GIx0xtNlym7HyC5qyXKqEkhjEtcdBxnV50FVJi65+0NFy4o3zgvWZL0h4C0YGWlJKM2bVKKUh8/rnxDvmZNupyucIPC5CqSi+jH0ZxZdSZVxzAYDPwz4B+i7kbxUamPqDWu1ssHv/tO+bCVJ0/6XzuROkWLgp+f0kYnTijJw8jI9z9PJBJ5J3nXLLn7icSu773O3DJzObn4JGigincV+gX0o0DFAmqHlnJ6PZw5o0wJb9NGSUKVLasULt+4URmxmC0bNGoEkybBkSPKtq1b4ZtvoGJF5W/Fr78qx3v992r8/RkzwCzjknWSlMpCfIJ8ePDsAc4OzjQu2ljtcEyGmdaMXxspb9zXE1Px92c0moGZ1oSz7EIVNd1q0rRoU3QGHd/t/i7Njnsg5AAVF1YkMDSQj2w/YneP3fT27J1mx8+qZNSkEKbp0t+XePbwGfYF7Pm4/scZd+ING2D+fKWT/8cfygf3jNCihVJD5NNPlQRBx47Qr58yaisNabQapbYUSsFzw9tWcnqPc2vOcX79ebTmWlr/3hpzqxdfnOzerUx1BKUor6NjWoUt0lrJkkrx85w54dAhZURgGv9by+zsneyTtV+QTxCPgh+lbzCZSOyzWLZ/tZ3ltZfzOPgxOdxy0GNPDxr+0hALGwu1w0segwHOnlVq67VrB/nyQZkyMGSI8jfm4UOws4OGDeHnn+HwYWXbtm3K1OdKlcD8LV9It2kD69dDgdcSc87OyvY2bTLm9b0gSaksJL7AeR/PPjJaIoXauLdhfYf1FHBI/MZ1dnBmfYf1tHHP2DeuyDwm1p2IBg3rzq/j2K0Pr8ux9ORSai+vzd2ou5TNV5bj/Y5TvWD1NIhUyKhJIUxTfIHzst3LZlwR25s3lZXxQPl2um7djDlvPBcX2LsX/u//lKTYwoXKh5Pz59P0NB69PDC3MSfsdBg3DtxI0XMj70SydcBWAGp8VwOnci8S+uHh0L278mGsXz8lySaMW9mysGMHODiAv78yjej5c7WjMhkFaxTEwdmBJLoXCYLWBzGz8EzWd1zPrWO3MiY4E3Xr2C0WlFvAkRlHACjnVY4vTn+BW003dQN7H4NBqaU3eza0b68koUqXhsGD4a+/4P59ZZGLBg3gp5+URHB4OGzfDiNGQOXKYJHMhFubNsoqmnv2wKpVyv+vXcvwhBRIUirLuHj/Iv7B/mg1WvqW66t2OCapjXsbrg+9jm8XX7xdvfHt4su1odckISU+SOl8pelWthsAI3aNSNU3zQBx+ji8d3jTe3NvYvWxtHVvy4HeByiYvWBahpulyahJIUxP5O1Irmy/AoBHT4+MOalOB926Kd9WV6gAEyZkzHlfZ24OP/ygrFyXL5/yQadCBWUqXCr/1rzOJqcNpbsoheOPzU7+FysGg4G/vf7mefhznMo5UePbGvEPwBdfwK1bytSwadPSJE6RASpWVEZn2Nkp/+bat0/XYvuZidZMS6NfX6yI/HpiSqPcanxXg0J1C2HQGTi35hyLKi1iWc1lXNx8EYM+bd7PmYEuRsfu73ezuOpi7l+4TzanbHTe2pnmC5pjZW+ldnhvMhiUxQLmzIEOHZTf1Z98AoMGKSOW7t1TklD168OPPyq1A8PDlSTwqFFQpUryk1BvY2YGtWpBp07K/zNwyt6rJCmVRcQXOG9atCnODs4qR2O6zLRm1HStyWc5P6Oma0358CnSxPha47E0s2TP9T3s/G9nip//6Pkjmq1qxvTD0wEYW3Msa9uvxc7SLq1DzfJk1KQQpuXUH6cw6A24fOpC7mK5M+akkycro5Ts7JRvny0tM+a8SalXT1mNqX59ePYM+vSBrl0hIiJNDl9pYCUAzv91niehT5L1nMBlgVzeehkzSzNa/d7qZaHhFStg7VolobZypXINhemoVg22bAFra+X/nTtDXJzaUZkE9zbudFjfAYcCDom2Ozg70GF9B+pMqEP3Xd3pf7I/ZbqVQWuuJXhfMKtbrma2+2yOzz9O7LNYlaI3DnfP3mVRlUXs/2E/Bp2BTzp9woCzAyjapKjaob1kMCh1BufNg88/V6YmlywJAwfCunVKEsrGRvm9/cMP8O+/ShJq50749lvlPab235R0IHO4soDncc9Zfmo5AP3KS4FzIYyNaw5XBlUcxLTD0xixawT1C9dP9uptF+9fpMXqFlx6cAlbC1uWt1pOu5Lt0jnirK2NextaFm/J/pD93Im8g5O9EzUK1pAktRBGxmAwJEzdy7AC50eOwPffKz/PmqWM9jEG+fIp0zsmT1YKiK9apazCtGYNlCv3QYd29HDEpZoLNw7e4MTCE9T8vuY7938U/IjtQ7cDUHtC7ZdLsV+7pnwwAxg7Vhl5I0xPrVpKsf3mzZXpRj16wO+/qzYCw5S4t3GneLMi3PltLVd276dInRo4De6A1vLlSBhHD0da/96auj/V5chvRzgx/wQPLj1g6xdb2fPdHioMqEClgZWwy5t1Erp6nZ5Dvxxiz/d70MXosMltQ9O5TSnVvlTan0ynQ+PvT4F9+9DY2UHt2u/+t20wwKVLyhcVe/Yo/w8LS7yPtbWSbKpdW3n/xBcjz0JkpFQWkKjAeREpcC6EMfq2xrc4WDlwKuwUq8+uTtZzdlzZQeVFlbn04BIuDi4c6H1AElIZxExrRi23WnQq3YlabrUkISWEEbp5+CYPLj7AwtaCUh3S4cPJ6yIilJEhOp3yDXiPHul/zpTQamHkSNi3DwoWhCtXoGpVZSnxD5zOV3GgkkA6Mf8EulhdkvsZ9AY299lMTGQMzlWdqTq8qvJA/JTHyEilQPvIkR8Uj1BZgwbK1CNzcyUB2q+fsmqYeDcfH7SFP6bA112p+c98CnzdFW3hj8HH541dHZwdqD+pPl/d+IqGMxqSwy0HT+8/Zd/4fUwvOJ3NXpu5F3RPhReRsR5eeciymsvYNWIXuhgdxZoVY8DZAemTkPLxATc3zOvXp8K0aZjXrw9ubonbJz4JtWCB8vegQAEoUUKZlrxmjZKQsrJSElDjxim/jx89Ulax/O47qF49yyWkQJJSWUL81L2+nn3lg5MQRiq3bW5Gfqp0wv9v9/8RHRed5L4Gg4Hph6bTZFUTHkc/pppLNY55HcPD0SODohVCCOMXP0qqZLuSGVNLZNAguHoVXF2VqRmvL7VtLKpVg5MnoVUrpebP0KFKYeqHD1N9SPe27tjltSPyViQXN11Mcr/j845zze8a5jbmtFre6mXh+Z9/Vmql2NsrKxXKqBrT17w5/PmnkgxdskR5f6RRLbNMycdHWV3t5s3E22/dUra/JTEFYGVvRZWhVRh8eTDt1rajQKUC6KJ1nFx0kjkl57Cq2Squ7bmW6pqlxspgMHBs7jHmlZ3HjQM3sLS3pMXiFnTc3JFsjtnS/oTva58vv4QuXZTV64oXh/79lX//d+4oSaZatZQRoP7+ShJq924YPRpq1MiSSajXSVIqk7tw/0JCgfM+5fqoHY4Q4h2GVhmKUzYnrj+6nrBa5uui46Lps7kP3ju90Rv09Pboze7uu8mXLV8GRyuEEMYr9mksZ1efBaBsz7Lpf8KVK5Vkilar/JwjR/qf80PkyqV8yJo5U6lPsmkTeHgoiaFUMLcyp1w/ZRpgUgXPH155iO83vgDUm1SP3EVf1Pg6dkz5sAbKlMdChVIVgzBC7dopU/c0Gpg7F4YPl8TU2+h0SnL4bdcmftuwYcp+SdCaaynVvhR9Dveh1/5elGhVAjRweetlfq/zOwvKL+D0ytPvHMloKiJuRrCi4Qr+GfAPsU9jcavlxpenv8Sztyea9Pgy4H3tYzAoX0SsWgW3byu/U2vWhDFjlCl7jx4p/x8zBj77TJmuJxKRpFQmFz9KqlmxZlLgXAgjZ2thy9haYwEY7z+erZe28ueZP9l7fS86vY6wJ2HU+b0OSwOXotVomd5wOotaLMLKXL5hEUKIVwX5BBETGUMOtxzpvwT41avKt+SgfPP96afpe760otEoy4wfOgRFisCNG8oHqZ9+StVUqwr9K6Ax03B973Xunrub6DG9Ts/GnhuVD5C13RKKoxMVpRRdj4tTVp7q1i0tXpkwJl26wKJFys/TpytTlERi+/e/OQLnVQaD8v7cv/+9h9JoNBSsXpDPN3zOoIuDqDCgAuY25oSeDGVD1w3M/HgmB6Yc4Pnj52n4AjKGwWDg1B+nmPPJHK76XsXc2pxGvzaiu193crjlSL8T79v37vaJ1727MgLq0SOldtTYscoIKUlCvZckpTKxRAXOy0mBcyFMQW/P3jhlc+LBswc0+7MZnX06U3t5bfJPy0+pOaU4eOMgOaxzsK3LNoZVGZY+3wgJIYSJi5+6V7ZnWTTadPw9GRur1A2JjFRqgfzf/6XfudJLuXIQEKAkD3Q65TU0bAihoSk6jIOzAyValgDg2JzEo6UOzzisTLHJZknLJS1ftsnw4Ur9lQIFlJE08jctc+rdG2bPVn7+6SdlVTHx0okTydtvwgTYtg2iky7x8KrcRXPTdHZTvgr5itoTamOXz46ImxHs+t8uprtMZ4f3Dh4FP0p93Bko6l4U69qtY2P3jUQ/jqZApQL0P9mfykMqp8/v+JgYZcW7AQOgbdvkPadRI6VWlI1N2seTyUlSKhP76/xfPHz2EBcHFxoVaaR2OEKIZNh8cTN3ntx5Y/vdqLs8ePaA/Nnyc6TvERoUbqBCdEIIYfweXX/Etd3XAPDo4ZG+Jxs3TllxL3t2WLFCKexsiuJrOS1ZAra2sGuXMp3P1zdFh4kveH5q+Smu/HOF8H3hnFp+Cr9v/QBoOL3hyxENmzfD/BdT1X//XZlSKDKvAQPgl1+Un7//HqZMUTcetRkM8O+/0KIFfP118p6zezc0aQJ58kD79spU4fDw9z7NNo8tn333GcOuD6PF4hZ8VPIjYiJjODz9MDMLz2R9x/XcOnbrA19Q+rmw8QJzSs0hyCcIrbmW2j/UpveB3uQpkSdtT/T4MaxeDZ06wUcfKcn5uXOTdY0BcHJK23iyENWTUrNnz8bNzQ1ra2sqV67M0aNHk9x32bJlaDSaRDfr14bD+fj40KBBA3Lnzo1GoyEwMPCN4zx//pyBAweSO3dusmXLRtu2bQl7fWnGTGBBwIsC5+WkwLkQpkCn1zF0+9B37qPRaCics3AGRSSEEKYncHkgAIXqFErfKR3+/sqoD1BWWnJ1Tb9zZQSNBnr1Umo8ffKJskpUw4bKyKm4uGQdwq22G/YF7ImNimVtq7UETwtmq9dW9DF6HD0d8ezjqewYGgp9XtQ6HT4c6tRJpxcljIq3N/z4o/Lz//4Hv/2mbjxq0OmUem7VqilFrv/+W9n+rileGo2SJOnXD/LnhydPlNUNu3aFvHmhXj3lWoaEvPPU5tbmePb25MuzX9L5n84UqlsIg87AuTXnWFRpEctqLuPi5osY9MZR9+v5o+ds7LGRNa3X8PTeU/J+khevY1589n+foTVPozTGzZswZ47yu+6jj5SE1OrVymqq+fKBl5eSQC9QIOmRnBoNuLgo7SlSRdWk1Jo1a/D29mbMmDEEBARQtmxZGjZsyN27d5N8joODA3fu3Em4BQcHJ3o8KiqK6tWrM2nSpCSP8dVXX/H333+zbt06/P39uX37Nm3atEmz12UMgu4FsS94n1Lg3FMKnAthCvaH7OdmxLvnrN+KvMX+kPfXFBBCiKzIoDdwatkpADx6eaTfiR4+VD4QGgzK1KQOHdLvXBmtZEk4elT5AGwwKIm3WrXe+4EX4MKGC0TeinzrY6GBoVzYcEE5Zp8+cP8+lCnzMkkhsoZvv1VGSgEMGQILF6obT0Z59kwZGejurkwHO3xYKYjdty8EBSmjnjSaNxMf8ffnzVOef+OG8v789lsoVUpJGPv5KdfS1VWZjjt+PJw6lWRReY1GQ9HGRem+qzv9T/anTLcyaM21BO8LZnXL1cx2n83x+ceJfRabzhclaf/5/sfc0nM59fspNFoNn474FK/jXjh6OH7YgQ0GOHtW+b1TsaKSTBo4UJmqFxsLJUrAiBFw8KBStHzBAmUlyZkzlecn1T4zZsiqoR9A1THG06ZNw8vLi169egEwb948tm7dypIlSxg5cuRbn6PRaHB0TPofY7cXBRKvX7/+1scfP37M4sWLWbVqFXVefCuzdOlS3N3dOXz4MFWqVPmAV2Q8Xi1wXsChgMrRCCGS407km9P2PmQ/IYTIaq77X+fR9UdYOVjh3sY9fU5iMCjfnt+8CUWLwq+/ps951GRjo3wArltXea0HDijT+ZYtU6YbvYVep2f70O3vPOz2Ydspfns32n/+UZZBX7VKlkPPisaNU5I0U6dC//7KKKHMWuT+wQNlJM5vv8G9e8q2HDmU6YyDB0P859oSJZTRT0OHJi6q7eysJDziB1BotUoypWJFJbFy5YqyeubGjcr79ORJ5TZmDLi5QcuWyq1GjbdOL3b0cKT1762p+1Ndjvx2hBPzT/Dg0gO2frGVPd/tocKAClQaWAm7vHbpeJFeiomKYdeIXQmreOYqkotWy1vhUs0l9QfV6ZRrs2mTcvvvv5ePaTRQpQq0aqVcp+LF336MNm2S1z4iVVQbKRUTE8OJEyeoV6/ey2C0WurVq8ehQ4eSfN6TJ09wdXXFxcWFli1bcu7cuRSd98SJE8TGxiY6b4kSJShYsOA7z2tKXi1w3r98f5WjEUIkl5N98uaiJ3c/IYTIauJHSZX6vBQWthbpc5JFi5TpNxYW8OefkC1b+pzHGHTooHzArVBBqavSsqXyoewthZZD9ocQcTMi6WMZwPLGf8p0PYDJk5WRHiLr0WiU9h80SEny9uwJa9eqHVXaunZNGb1UsKCyKue9e8rP06crow5//PFlQipemzZw/Tpxvr4c9/YmztdXOc67Eh5Fiijvqf37lWmxixcriWNra7h+XUma16mjTEXr3l353fXkyRuHcXB2oP6k+nx14ysazlBqvz29/5R94/cxveB0Nntt5l7QvbS9Rq+5cfAG8z3mJySkKg6sSP/A/qlLSD19qiSgevVSrnPNmjBtmpKQsrKCpk2VUXp37iijov73v6QTUvFS0z4iWVQbKXX//n10Oh358uVLtD1fvnxcuHDhrc8pXrw4S5YsoUyZMjx+/JipU6dSrVo1zp07h7Ozc7LOGxoaiqWlJTly5HjjvKHvWGUkOjqa6Ff+AEdEKH90Y2NjiY1N26GN8cdL7XFXn11N+PNwCjoUpE7BOmkeX1b3oe0j0o+pt00VpyoUsC/A7cjbGHhzyLUGDQUcClDFqYpJvkZTb5/MTton+eQaGafoyGjOrz8PpOPUvQsXlKQMKNPaypdPn/MYk48/VkYZjBqlfKibOVMp0LxmjfKB+IXIO2+fthdPSxxt+AttTDQ0aKAkJETWpdEoCZPnz5VEb+fOSrKgZUu1I/swJ04oRdzXrQO9Xtnm4QHffKMUJ7d4T7LczAxDzZrcioqibM2aKZsSljevMp24d2+IilIWKti0Salb9eCBspjBH38o17lePWV0UPPmSsLqBSt7K6oMrUKlgZUI2hDEoamHuHX0FicXneTkopMUbVqUqsOr4lbLLc1WgI6LjmPvmL0cnHIQg96Ag7MDLZa0oHD9FNZQvXcPtmxRXvPOncpovHg5c0KzZsq/r4YNU/9lwoe0j0iSSS0RUrVqVapWrZpwv1q1ari7uzN//nwmTJiQrueeOHEi48aNe2P7zp07sbW1TZdz+qZwxZN4Uy4rq1l8avspO7bvSMuQxCtS2z4i/Zly23TN3ZVJkW+viWfAQJdcXUz+fW3K7ZMVSPu839OnT9UOQbzFubXniH0aS+7iuXGukrwvK1MkOlopgvvsmfKBzts77c9hrCwtlZXT6tSBHj0gIECpXTN/vnJNAHsn+3ceojZ7cCIUnUNOzJYuVaYhiaxNq1VqJUVHK8mS9u2VhELjxmpHljIGA+zYoSSjdu9+ub1+fSUZVa9e0kWy04udnZJ0atVKqTt18KAyxW/TJrh6FbZuVW4aDVStqiRrWrWCYsUA0JprKdW+FCXbleTGgRsc+uUQFzZd4PLWy1zeehlHT0eqDq9KqQ6lMLNIfWImNDCUDd02cPesUlO6bPeyNPq1EdY53lH4/VXx0xc3bVKS5/GJQFBqbMVPy6te/f0JQaEa1ZJSefLkwczM7I1V78LCwt5ZM+pVFhYWeHp6cuXKlWSf19HRkZiYGB49epRotNT7zjtq1Ci8X+l8RERE4OLiQoMGDXBwcEj2+ZMjNjYWX19f6tevj0UK3zzn753nfOB5zDRm/NT+JwrYSz2ptPYh7SPSV2ZomyY0odyFcnj7enMr8uXyvM4OzvxS7xdal2itYnQfJjO0T2Ym7ZN88aOlhXEJXBoIKKOk0uob/ERGjYLAQGU59t9/z5pJlaZNlWvQpQvs26eMbtm1C2bOpGCNgjg4OxBxK4LXB/u6cp1POQCAZslCZQUxIUAZabJkiTJiat06ZSrU1q2msSJjbKyyUtuUKXDmjLLNzAw6doSvv1ZGSBkDc3P47DPl9ssvcO7cywTV8eNKwurgQaXAd4kSLxM5lSqh0WopWL0gBasX5MHlBxyefpjAZYGEngxlQ9cN+I30o9KQSpTvVx7r7MlMJAH6OD3/TvoX/7H+6OP02H5kS/MFzSnRqsR7nqhXRqPFx/96KR9Pz5cJtjJlMj4ZKFJFtaSUpaUl5cuXx8/Pj1atWgGg1+vx8/NjUDKH8+p0Os6cOUOTJk2Sfd7y5ctjYWGBn58fbdu2BeDixYuEhIQkGoX1OisrK6zeUojRwsIi3TrvqTn2stPLAKXAuVsut7QPSiRIz7YXH8bU26ZD6Q60LdWW/SH7uRN5Byd7J2oUrIGZNnMMETb19snspH3eT66P8Xlw6QE3DtxAo9VQtlvZtD/B9u1KLRiApUvBKQvX9nN2Vlb7mjBBuS1ZAocPo12zhka/NmJtu7Vo0FOQYOx5QjSWNGULGuBR3bbkeNH/FiKBubmy+lxMjJJoaN5cGXlUvbrakb1dRIRSj2jGjJdFr+3slEUBhg1TRugYK40GPvlEuX33nRL/5s3Kdd+9W5mi/PPPys3RUalP1bIl1KlD7qK5aTqnKbXH1+b4vOMcnXWUiJsR7PrfLvZN2Ee5vuWoPLQyOVxzJJxOr9MTsj+EyDuR2DvZU7BGQR5eecjG7hu5dVT58rVE6xI0m9cs6WLqMTGwZ8/LEVG3b798zMxMWR20ZUslVmO+9iJJqk7f8/b2pkePHlSoUIFKlSoxY8YMoqKiElbj6969OwUKFGDixIkAjB8/nipVqlCkSBEePXrElClTCA4Opm/fvgnHfPjwISEhIdx+8Y/14sWLgDJCytHRkezZs9OnTx+8vb3JlSsXDg4ODB48mKpVq5r8ynvPYp9JgXMhMgkzrRm13GqpHYYQQpiEwGWBABRpVAT7/O+eRpZiYWHKlDVQ6iA1a5a2xzdF5ubKCmo1ayqjps6fh4oVcZ85kz7Dc5B9+hjsdY8TPSU2R25ybFymTrzC+FlYKHXKWrVSksBNmiij8CpVUjuyl27fVmqqzZsHj1/8+86XT6kz98UXSt0iU+PsrKwEOGCA8pq2bVNGIf3zj1I4fcEC5ZYtGzRqBK1aYdukCZ999xnVvq7GmVVnOPTLIe6dv8fh6Yc5MvMIJduVpOrwqkTciGD70O2JFkCwymFFbFQs+lg9VtmtaPxbY8p0LfPm6NbHj5UYNm1SYnp1hPIrsdCkiWled5GIqkmpzz//nHv37jF69GhCQ0Px8PBg+/btCcXPQ0JC0L4yNDo8PBwvLy9CQ0PJmTMn5cuX5+DBg5QsWTJhn82bNycktQA6duwIwJgxYxg7diwA06dPR6vV0rZtW6Kjo2nYsCFz5szJgFecvtafX0/483Bcs7vSoHADtcMRQgghhEh3ep2eU78rq+6leYFzvV5ZGezuXWVkweTJaXt8U1enDpw6pazqtWMH9OuHM2/M3sMAWDx6oBQflpWqRFKsrJTV4Zo2VUbGNGyojN7x9FQ3rvPnYepUWLFCmbIHykptX38NXbsqK91lBtmzK1MPO3ZU6nzt3Zt4dNL69crtxXRA81at8GzZEo9eX3Jl+xUO/XKIa37XOLfmHOfWKNPqNOhxfTFqMpJshDxyxYCWfGXy0XlrZxycXymDEz9qa+NG5dyvLioSP2qrVSuoXTvzXHMBGEGh80GDBiU5XW/v3r2J7k+fPp3p8UOnk9CzZ0969uz5zn2sra2ZPXs2s2fPTkmoRm9BwAIA+pbrm2mm+QghhBBCvMu1XdeIvBWJTS4bijUvlrYH/+03ZdSGtTX8+SfY2KTt8TODvHmVEQ2TJyt1t4DXq7hoQJk2NGyYMs1GVqwSSbGxUVaLa9hQKVxdv76SoPjkk4yNw2CA/fuVelFbtrzcXr26Ury8WbPMXVfOykppg4YNYdYspY7Tpk1KwujcOSVZuHs3DBmCxtOToi1bUnRqS0IN9Tn4yyHOrDxDCc7TiO1k5+Uop8c4sJ1G3A53IJujnVKLKz7xdfx44hheq2+Vqa93Fqd6UkqkjXN3z/FvyL+Yaczo7dlb7XCEEEIIITLE6eWnAfik8yeYW6Vh1zYwEP73P+XnX37J+A/FpkSrhfeVwTAY4MYN5YN+rVoZEpYwUXZ2SqKzfn04elRZvc7fXxmdlN50OiXxMnmycm5QEqqtWinJqHfUIM60tFqoWFG5/fDDmyvenTyp3MaOxdHVlXrla5OT69Ri7xuHciCCDqzl0o1AdK4z0N4Oeflg/EqA8YmoYmn8JYMwWpKUyiQWBiwEoHnx5uS3lxVNhBBCCJF56XV6gv2Dub/zPrc3KnVEPXul4RSfp0+hUyelwG6LFvDll2l37Mzqzp203U9kbQ4OyijFOnWUBHGdOsqKj4ULp8/5nj2DZctg2jQl6QLKaKGePcHbWxIkrypSBIYPV2737ikjyTZtUqbnBgfjELyM2ijTdt86ahIoziW4jXKN69dXklDNmys1ukSWI0mpTEAKnAshhBAiqwjyCXqjeK7WQkv4tXCcyqXRqnje3soqVE5OsHixLCueHMldkTArr1woUiZnTiXRUbu2MmWsTh1lpF3Bgml3jvv3Yc4cZaru/fsvzztwoLKwgSRJ3u2jj6BXL+X29Cn4+vL0x2nYHtv3RkLqdeE9vyLnb+OVwuUiS5OJmZnAuvPrePT8kRQ4F0IIIUSmFuQTxNp2axMlpAD0sXrWtV9HkE/Qh5/Exwfmz1cSUX/8AXnyfPgxs4IaNZSVvJJK4Gk04OKi7CdEcn30kbIKX7FiEBKiJKZerLL+Qa5eVZJOBQvCmDFKQsrNTVld78YNmDBBElIpZWsLLVtiPbRfsnbPXq+8JKQEIEmpTGHBCaXAuVc5L7QaaVIhhBBCZD56nZ7tQ7e/ubTbK7YP245ep0/9SW7ehL59lZ//9z+oWzf1x8pqzMzg11+Vn19PTMXfnzFDipyLlHN0BD8/KFQI/vtPeV/evZu6Yx0/Dp9/DkWLwuzZyrS9cuWUhQwuX4bBg5WaViLVtAUKpOl+IvOTDIaJO3f3HAduHJAC50IIIYTI1EL2h7wxQioRA0TciCBkf0jS+7yLTgfdukF4OFSoAOPHp+44WVmbNsqS8a9/2HR2Vra3aaNOXML0OTsrq725uChTa+vVgwcPkvdcgwG2bVNGWVWsCGvXgl6vrCzn56ckqjp2BHOpbJMmXoyaNCQxgc+AjJoUiUlSysTFj5JqUbwFTvYyR18IIYQQmVPkncg03e8NkyYpS8/b2cGqVWBpmbrjZHVt2sD168T5+nLc25s4X1+4dk0SUuLDubkpSSQnJzhzBho0UBJTe/cqI5327lWSy/FiYmD5cihTBpo0gT17lMRTt25w6tTLQupSMy5tvRg1qdGA4bVra9BolMstoybFKyQdbMKexT7j99O/A1LgXAghhBCZm72TfZrul8iRIzB6tPLz7NnK1B6RemZmGGrW5FZUFGVr1pQPnyLtFC2qJKZq1oSAAMifX0k+xXN2hokTITRUSXzcuqVsz5YN+vWDYcOUUToifb0YNakZOlSZFv2CxtlZaRdJUotXyEgpExZf4Nwthxv1C9dXOxwhhBBCqGj27Nm4ublhbW1N5cqVOXr0aJL7Llu2DI1Gk+hmbW2daB8fHx8aNGhA7ty50Wg0BAYGpvMreLeCNQri4Ozw5hrj8TTg4OJAwRopXJkrIgI6d1ZGWHTsCN27f3CsQoh05O4OI0cqP7+akAIlAdKtG3zzjZKQcnSEn39Wipf/8oskpDLSi1GT7NmjjD7ds0dGTYq3kqSUCZt/Yj4gBc6FEEKIrG7NmjV4e3szZswYAgICKFu2LA0bNuTuO4oBOzg4cOfOnYRbcHBwosejoqKoXr06kyZNSu/wk0VrpqXRr42UO68npl7cbzSjEVqzFPaJBg5UVuJydYW5c2UqjxDGTqeD6dPfvY+5OSxcqCRFRoyAHDkyIjLxOjMzqFULOnVS/i+jJsVbyPQ9E3X27lkO3jiIudZcCpwLIYQQWdy0adPw8vKiV69eAMybN4+tW7eyZMkSRsaPKHiNRqPB0dExyWN269YNgOvXr6d5vKnl3sadDus7sH3o9kRFzx2cHWg0oxHubdxTdsAVK5SbVqt8ky8fXIUwfvv3J5oS9lZxcVCkCFhZZUxMQohUk6SUiXq1wLljtqQ7lEIIIYTI3GJiYjhx4gSjRo1K2KbVaqlXrx6HDh1K8nlPnjzB1dUVvV5PuXLl+OmnnyhVqtQHxRIdHU10dHTC/YgIJXEUGxtLbGzsBx07XpHmRRjQZADX9l7jsO9hqtSvQqFahdCaaVN2jqtXMR8wAA2g++479BUrQhrFKEhoi7Rqd5G2TLl9NDduJOtDbNyNGxhM8PWZcttkBdI+yZfcayRJKRP0NPYpv5+SAudCCCGEgPv376PT6ciXL1+i7fny5ePChQtvfU7x4sVZsmQJZcqU4fHjx0ydOpVq1apx7tw5nJ2dUx3LxIkTGTdu3Bvbd+7cia2tbaqPm5Scn+XkYvRFLu64mKLnaeLiqP7tt+SKjOSBuzsHypbF8M8/aR6fAF9fX7VDEO9giu2TOziY6snY73BwMA9M+H1tim2TlUj7vN/Tp0+TtZ8kpUzQunPreBz9mEI5ClHv43pqhyOEEEIIE1O1alWqVq2acL9atWq4u7szf/58JkyYkOrjjho1Cm9v74T7ERERuLi40KBBAxwcHD4o5tfFxsbi6+tL/fr1sbCwSNFztaNHY3bpEobs2XH4+28aF0xhcXTxXh/SPiL9mXT7NGyIYd48uH0bjcHwxsMGjQYKFKDy11+bZA0jk26bLEDaJ/niR0u/jySlTJAUOBdCCCFEvDx58mBmZkZYWFii7WFhYe+sGfUqCwsLPD09uXLlygfFYmVlhdVbarhYWFikW+c9xcf294cXxds1CxZgUbhwusQlFOnZ9uLDmWT7WFjAzJnQrp2yMMGriSmNRln34NdfsXhtRVFTY5Jtk4VI+7xfcq+PZDRMzJmwMxy6eQhzrTm9PHupHY4QQgghVGZpaUn58uXx8/NL2KbX6/Hz80s0GupddDodZ86cwcnJKb3CNA4PH0LXrsqH2N69oUMHtSMSQqRGmzawfj0UKJB4u7Ozsr1NG3XiEkKkmIyUMjHxBc5bFm8pBc6FEEIIAYC3tzc9evSgQoUKVKpUiRkzZhAVFZWwGl/37t0pUKAAEydOBGD8+PFUqVKFIkWK8OjRI6ZMmUJwcDB9+/ZNOObDhw8JCQnh9u3bAFy8qNRtcnR0TPYILKNiMICXl7JqV7Fi8OuvakckhPgQbdpAy5bKanx37oCTE9SoYZJT9oTIyiQpZUKexj7lj9N/AFLgXAghhBAvff7559y7d4/Ro0cTGhqKh4cH27dvTyh+HhISglb7coB8eHg4Xl5ehIaGkjNnTsqXL8/BgwcpWbJkwj6bN29OSGoBdOzYEYAxY8YwduzYjHlhaWnRIvDxUab+rFoF2bKpHZEQ4kOZmUGtWmpHIYT4AJKUMiFrz63lcfRjPs75MXU/rqt2OEIIIYQwIoMGDWLQoEFvfWzv3r2J7k+fPp3p06e/83g9e/akZ8+eaRSdyoKCYOhQ5eeffoLy5dWNRwghhBCA1JQyKVLgXAghhBAihaKjoVMnePYM6teHV1YHFEIIIYS6JLNhIk6HnebwzcOYa83p6dFT7XCEEEIIIUzDqFFw6hTkyQPLl4NWur9CCCGEsZC/yiYivsB5qxKtpMC5EEIIIURybN8O8dMUly5VCiELIYQQwmhIUsoERMVESYFzIYQQQoiUCAuDHj2UnwcPhmbN1I1HCCGEEG+QpJQJWHtuLRHREXyc82PqFKqjdjhCCCGEEMZNr4eePeHuXfjkE5g8We2IhBBCCPEWkpQyAfEFzvuV6ycFzoUQQggh3mfmTGXqnrU1rF6t/F8IIYQQRkcyHEbuVOgpjtw6IgXOhRBCCCGSIzAQRoxQfp42DUqVUjUcIYQQQiRNklJGLr7AeesSrcmXLZ/K0QghhBBCGLGnT6FTJ4iJgRYt4Isv1I5ICCGEEO8gSSkjFhUTxYozKwApcC6EEEII8V5ffQUXLkD+/LB4MWg0akckhBBCiHeQpJQRWxe0jojoCArnLEztQrXVDkcIIYQQwnj5+MCCBUoi6vffIU8etSMSQgghxHtIUsqILTy5EIB+5aXAuRBCCCFEkm7ehL59lZ//9z+oW1fdeIQQQgiRLOZqByAS0+l1+Af7sz50PcdCj2GukQLnQgghhBCJ6HRo/P0psG8fGhsb+PFHCA+HChVg/Hi1oxNCCCFEMhnF8JvZs2fj5uaGtbU1lStX5ujRo0nuu2zZMjQaTaKb9WvL/BoMBkaPHo2TkxM2NjbUq1ePy5cvJ9rHzc3tjeP8/PPP6fL6kssnyAe3X92ov7I+K0KVWlIWZhb8G/KvqnEJIYQQQhgNHx9wc8O8fn0qTJuGecOGsG8fWFnBn3+CpaXaEQohhBAimVRPSq1ZswZvb2/GjBlDQEAAZcuWpWHDhty9ezfJ5zg4OHDnzp2EW3BwcKLHJ0+ezMyZM5k3bx5HjhzBzs6Ohg0b8vz580T7jR8/PtFxBg8enC6vMTl8gnxot7YdNyNuJtr+LO4Z7da2wyfIR6XIhBBCCCGMhI8PtGunTNd7XXQ0nD6d8TEJIYQQItVUT0pNmzYNLy8vevXqRcmSJZk3bx62trYsWbIkyedoNBocHR0Tbvny5Ut4zGAwMGPGDL777jtatmxJmTJl+P3337l9+zYbN25MdBx7e/tEx7Gzs0uvl/lOOr2OoduHYsCQ5D7Dtg9Dp9dlYFRCCCGEEEZEp4OhQ8GQRH9Jo4Fhw5T9hBBCCGESVK0pFRMTw4kTJxg1alTCNq1WS7169Th06FCSz3vy5Amurq7o9XrKlSvHTz/9RKlSpQC4du0aoaGh1KtXL2H/7NmzU7lyZQ4dOkTHjh0Ttv/8889MmDCBggUL0rlzZ7766ivMzd9+SaKjo4mOjk64HxERAUBsbCyxsbGpuwAv+Af7vzFC6lUGDNyIuMGeq3uo6Vrzg84lPlx8e39ou4u0J21j3KR9jJu0T/LJNVLJ/v1vHyEVz2CAGzeU/WrVyrCwhBBCCJF6qial7t+/j06nSzTSCSBfvnxcuHDhrc8pXrw4S5YsoUyZMjx+/JipU6dSrVo1zp07h7OzM6GhoQnHeP2Y8Y8BDBkyhHLlypErVy4OHjzIqFGjuHPnDtOmTXvreSdOnMi4cePe2L5z505sbW1T9Lpfty98X7L22/bvNqLORX3QuUTa8fX1VTsEkQRpG+Mm7WPcpH3e7+nTp2qHkDXduZO2+wkhhBBCdSa3+l7VqlWpWrVqwv1q1arh7u7O/PnzmTBhQrKP4+3tnfBzmTJlsLS0pH///kycOBErK6s39h81alSi50RERODi4kKDBg1wcHBI5atR2AXbMS347cmwVzWu3lhGShmB2NhYfH19qV+/PhYWFmqHI14hbWPcpH2Mm7RP8sWPlhYZzMkpbfcTQgghhOpUTUrlyZMHMzMzwsLCEm0PCwvD0dExWcewsLDA09OTK1euACQ8LywsDKdXOiVhYWF4eHgkeZzKlSsTFxfH9evXKV68+BuPW1lZvTVZZWFh8cGd99of18bZwZlbEbfeWldKgwZnB2dqf1wbM63ZB51LpJ20aHuRPqRtjJu0j3GT9nk/uT4qqVEDnJ3h1q2315XSaJTHa9TI+NiEEEIIkSqqFjq3tLSkfPny+Pn5JWzT6/X4+fklGg31LjqdjjNnziQkoAoVKoSjo2OiY0ZERHDkyJF3HjMwMBCtVkvevHlT+WpSz0xrxq+NfgWUBNSr4u/PaDRDElJCCCGEyLrMzOBXpb+EJnF/KeH+jBnKfkIIIYQwCaqvvuft7c3ChQtZvnw5QUFBfPnll0RFRdGrVy8AunfvnqgQ+vjx49m5cydXr14lICCArl27EhwcTN++fQFlZb5hw4bxww8/sHnzZs6cOUP37t3Jnz8/rVq1AuDQoUPMmDGDU6dOcfXqVVauXMlXX31F165dyZkzZ4ZfA4A27m1Y32E9BRwKJNru7ODM+g7raePeRpW4hBBCCCGMRps2sH49FEjcX8LZWdneRvpLQgghhClRvabU559/zr179xg9ejShoaF4eHiwffv2hELlISEhaLUvc2fh4eF4eXkRGhpKzpw5KV++PAcPHqRkyZIJ+/zvf/8jKiqKfv368ejRI6pXr8727duxtrYGlKl4q1evZuzYsURHR1OoUCG++uqrRDWj1NDGvQ0ti7dkz9U9bPt3G42rN5Ype0IIIYQQr2rTBlq2JG7PHgK3bcOjcWPMa9eWEVJCCCGECVI9KQUwaNAgBg0a9NbH9u7dm+j+9OnTmT59+juPp9FoGD9+POPHj3/r4+XKlePw4cOpijW9mWnNqOlak6hzUdR0rSkJKSGEEEKI15mZYahZk1tRUZStWVMSUkIIIYSJUn36nhBCCCGEEEIIIYTIeiQpJYQQQgghhBBCCCEynFFM3zNFhhdLEUdERKT5sWNjY3n69CkRERGy7LQRkvYxXtI2xk3ax7hJ+yRf/N/++L6ASJr0l7IuaR/jJu1jvKRtjJu0T/Ilt78kSalUioyMBMDFxUXlSIQQQgihhsjISLJnz652GEZN+ktCCCFE1va+/pLGIF/zpYper+f27dvY29uj0WjS9NgRERG4uLhw48YNHBwc0vTY4sNJ+xgvaRvjJu1j3KR9ks9gMBAZGUn+/PkTrRAs3iT9paxL2se4SfsYL2kb4ybtk3zJ7S/JSKlU0mq1ODs7p+s5HBwc5B+6EZP2MV7SNsZN2se4Sfskj4yQSh7pLwlpH+Mm7WO8pG2Mm7RP8iSnvyRf7wkhhBBCCCGEEEKIDCdJKSGEEEIIIYQQQgiR4SQpZYSsrKwYM2YMVlZWaoci3kLax3hJ2xg3aR/jJu0jTI38mzVu0j7GTdrHeEnbGDdpn7Qnhc6FEEIIIYQQQgghRIaTkVJCCCGEEEIIIYQQIsNJUkoIIYQQQgghhBBCZDhJSgkhhBBCCCGEEEKIDCdJKSM0e/Zs3NzcsLa2pnLlyhw9elTtkLK8iRMnUrFiRezt7cmbNy+tWrXi4sWLaoclkvDzzz+j0WgYNmyY2qGIF27dukXXrl3JnTs3NjY2lC5dmuPHj6sdVpan0+n4/vvvKVSoEDY2NhQuXJgJEyYg5SaFKZD+knGSPpPpkP6S8ZH+knGS/lL6kqSUkVmzZg3e3t6MGTOGgIAAypYtS8OGDbl7967aoWVp/v7+DBw4kMOHD+Pr60tsbCwNGjQgKipK7dDEa44dO8b8+fMpU6aM2qGIF8LDw/n000+xsLBg27ZtnD9/nl9++YWcOXOqHVqWN2nSJObOncusWbMICgpi0qRJTJ48md9++03t0IR4J+kvGS/pM5kG6S8ZH+kvGS/pL6UvWX3PyFSuXJmKFSsya9YsAPR6PS4uLgwePJiRI0eqHJ2Id+/ePfLmzYu/vz+fffaZ2uGIF548eUK5cuWYM2cOP/zwAx4eHsyYMUPtsLK8kSNHcuDAAfbv3692KOI1zZo1I1++fCxevDhhW9u2bbGxsWHFihUqRibEu0l/yXRIn8n4SH/JOEl/yXhJfyl9yUgpIxITE8OJEyeoV69ewjatVku9evU4dOiQipGJ1z1+/BiAXLlyqRyJeNXAgQNp2rRpoveQUN/mzZupUKEC7du3J2/evHh6erJw4UK1wxJAtWrV8PPz49KlSwCcOnWKf//9l8aNG6scmRBJk/6SaZE+k/GR/pJxkv6S8ZL+UvoyVzsA8dL9+/fR6XTky5cv0fZ8+fJx4cIFlaISr9Pr9QwbNoxPP/2UTz75RO1wxAurV68mICCAY8eOqR2KeM3Vq1eZO3cu3t7efPvttxw7dowhQ4ZgaWlJjx491A4vSxs5ciQRERGUKFECMzMzdDodP/74I126dFE7NCGSJP0l0yF9JuMj/SXjJf0l4yX9pfQlSSkhUmjgwIGcPXuWf//9V+1QxAs3btxg6NCh+Pr6Ym1trXY44jV6vZ4KFSrw008/AeDp6cnZs2eZN2+edLJUtnbtWlauXMmqVasoVaoUgYGBDBs2jPz580vbCCE+mPSZjIv0l4yb9JeMl/SX0pckpYxInjx5MDMzIywsLNH2sLAwHB0dVYpKvGrQoEFs2bKFffv24ezsrHY44oUTJ05w9+5dypUrl7BNp9Oxb98+Zs2aRXR0NGZmZipGmLU5OTlRsmTJRNvc3d3566+/VIpIxPvmm28YOXIkHTt2BKB06dIEBwczceJE6WQJoyX9JdMgfSbjI/0l4yb9JeMl/aX0JTWljIilpSXly5fHz88vYZter8fPz4+qVauqGJkwGAwMGjSIDRs2sHv3bgoVKqR2SOIVdevW5cyZMwQGBibcKlSoQJcuXQgMDJQOlso+/fTTN5YDv3TpEq6uripFJOI9ffoUrTZxV8DMzAy9Xq9SREK8n/SXjJv0mYyX9JeMm/SXjJf0l9KXjJQyMt7e3vTo0YMKFSpQqVIlZsyYQVRUFL169VI7tCxt4MCBrFq1ik2bNmFvb09oaCgA2bNnx8bGRuXohL29/Ru1Kuzs7MidO7fUsDACX331FdWqVeOnn36iQ4cOHD16lAULFrBgwQK1Q8vymjdvzo8//kjBggUpVaoUJ0+eZNq0afTu3Vvt0IR4J+kvGS/pMxkv6S8ZN+kvGS/pL6UvjcFgMKgdhEhs1qxZTJkyhdDQUDw8PJg5cyaVK1dWO6wsTaPRvHX70qVL6dmzZ8YGI5KlVq1assSxEdmyZQujRo3i8uXLFCpUCG9vb7y8vNQOK8uLjIzk+++/Z8OGDdy9e5f8+fPTqVMnRo8ejaWlpdrhCfFO0l8yTtJnMi3SXzIu0l8yTtJfSl+SlBJCCCGEEEIIIYQQGU5qSgkhhBBCCCGEEEKIDCdJKSGEEEIIIYQQQgiR4SQpJYQQQgghhBBCCCEynCSlhBBCCCGEEEIIIUSGk6SUEEIIIYQQQgghhMhwkpQSQgghhBBCCCGEEBlOklJCCCGEEEIIIYQQIsNJUkoIIYQQQgghhBBCZDhJSgkhRDrSaDRs3LhR7TCEEEIIIYyW9JeEyLokKSWEyLR69uyJRqN549aoUSO1QxNCCCGEMArSXxJCqMlc7QCEECI9NWrUiKVLlybaZmVlpVI0QgghhBDGR/pLQgi1yEgpIUSmZmVlhaOjY6Jbzpw5AWWo+Ny5c2ncuDE2NjZ8/PHHrF+/PtHzz5w5Q506dbCxsSF37tz069ePJ0+eJNpnyZIllCpVCisrK5ycnBg0aFCix+/fv0/r1q2xtbWlaNGibN68OeGx8PBwunTpwkcffYSNjQ1FixZ9o1MohBBCCJGepL8khFCLJKWEEFna999/T9u2bTl16hRdunShY8eOBAUFARAVFUXDhg3JmTMnx44dY926dezatStRJ2ru3LkMHDiQfv36cebMGTZv3kyRIkUSnWPcuHF06NCB06dP06RJE7p06cLDhw8Tzn/+/Hm2bdtGUFAQc+fOJU+ePBl3AYQQQggh3kP6S0KIdGMQQohMqkePHgYzMzODnZ1dotuPP/5oMBgMBsDwxRdfJHpO5cqVDV9++aXBYDAYFixYYMiZM6fhyZMnCY9v3brVoNVqDaGhoQaDwWDInz+/4f/+7/+SjAEwfPfddwn3nzx5YgAM27ZtMxgMBkPz5s0NvXr1SpsXLIQQQgiRQtJfEkKoSWpKCSEytdq1azN37txE23LlypXwc9WqVRM9VrVqVQIDAwEICgqibNmy2NnZJTz+6aefotfruXjxIhqNhtu3b1O3bt13xlCmTJmEn+3s7HBwcODu3bsAfPnll7Rt25aAgAAaNGhAq1atqFatWqpeqxBCCCFEakh/SQihFklKCSEyNTs7uzeGh6cVGxubZO1nYWGR6L5Go0Gv1wPQuHFjgoOD+eeff/D19aVu3boMHDiQqVOnpnm8QgghhBBvI/0lIYRapKaUECJLO3z48Bv33d3dAXB3d+fUqVNERUUlPH7gwAG0Wi3FixfH3t4eNzc3/Pz8PiiGjz76iB49erBixQpmzJjBggULPuh4QgghhBBpSfpLQoj0IiOlhBCZWnR0NKGhoYm2mZubJxTHXLduHRUqVKB69eqsXLmSo0ePsnjxYgC6dOnCmDFj6NGjB2PHjuXevXsMHjyYbt26kS9fPgDGjh3LF198Qd68eWncuDGRkZEcOHCAwYMHJyu+0aNHU758eUqVKkV0dDRbtmxJ6OQJIYQQQmQE6S8JIdQiSSkhRKa2fft2nJycEm0rXrw4Fy5cAJSVXlavXs2AAQNwcnLizz//pGTJkgDY2tqyY8cOhg4dSsWKFbG1taVt27ZMmzYt4Vg9evTg+fPnTJ8+na+//po8efLQrl27ZMdnaWnJqFGjuH79OjY2NtSoUYPVq1enwSsXQgghhEge6S8JIdSiMRgMBrWDEEIINWg0GjZs2ECrVq3UDkUIIYQQwihJf0kIkZ6kppQQQgghhBBCCCGEyHCSlBJCCCGEEEIIIYQQGU6m7wkhhBBCCCGEEEKIDCcjpYQQQgghhBBCCCFEhpOklBBCCCGEEEIIIYTIcJKUEkIIIYQQQgghhBAZTpJSQgghhBBCCCGEECLDSVJKCCGEEEIIIYQQQmQ4SUoJIYQQQgghhBBCiAwnSSkhhBBCCCGEEEIIkeEkKSWEEEIIIYQQQgghMpwkpYQQQgghhBBCCCFEhvt/gjQ3/PIFMS4AAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1200x600 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_model_metrics(metrics, model_name):\n",
    "    plt.figure(figsize=(12, 6))  # 设置图形大小\n",
    "\n",
    "    # 绘制训练损失\n",
    "    plt.subplot(2, 2, 1)  # 2行2列的第1个图\n",
    "    plt.plot(metrics['train_loss'], label='Training Loss', marker='o', color='blue')\n",
    "    plt.title(f'{model_name} Training Loss')\n",
    "    plt.xlabel('Epochs')\n",
    "    plt.ylabel('Loss')\n",
    "    plt.grid()\n",
    "\n",
    "    # 绘制验证损失\n",
    "    plt.subplot(2, 2, 2)  # 2行2列的第2个图\n",
    "    plt.plot(metrics['val_loss'], label='Validation Loss', marker='o', color='orange')\n",
    "    plt.title(f'{model_name} Validation Loss')\n",
    "    plt.xlabel('Epochs')\n",
    "    plt.ylabel('Loss')\n",
    "    plt.grid()\n",
    "\n",
    "    # 绘制验证准确率\n",
    "    plt.subplot(2, 2, 3)  # 2行2列的第3个图\n",
    "    plt.plot(metrics['val_accuracy'], label='Validation Accuracy', marker='o', color='green')\n",
    "    plt.title(f'{model_name} Validation Accuracy')\n",
    "    plt.xlabel('Epochs')\n",
    "    plt.ylabel('Accuracy')\n",
    "    plt.grid()\n",
    "\n",
    "    # 绘制验证精确率和召回率\n",
    "    plt.subplot(2, 2, 4)  # 2行2列的第4个图\n",
    "    plt.plot(metrics['val_precision'], label='Validation Precision', marker='o', color='purple')\n",
    "    plt.plot(metrics['val_recall'], label='Validation Recall', marker='o', color='red')\n",
    "    plt.title(f'{model_name} Validation Precision & Recall')\n",
    "    plt.xlabel('Epochs')\n",
    "    plt.ylabel('Score')\n",
    "    plt.legend()\n",
    "    plt.grid()\n",
    "\n",
    "    plt.tight_layout()  # 自动调整子图参数\n",
    "    plt.show()  # 显示图形\n",
    "\n",
    "# 准备数据字典\n",
    "rnn_metrics = {\n",
    "    'train_loss': rnn_losses,\n",
    "    'val_loss': rnn_val_losses,\n",
    "    'val_accuracy': rnn_val_accuracies,\n",
    "    'val_precision': rnn_val_precisions,\n",
    "    'val_recall': rnn_val_recalls,\n",
    "}\n",
    "\n",
    "lstm_metrics = {\n",
    "    'train_loss': lstm_losses,\n",
    "    'val_loss': lstm_val_losses,\n",
    "    'val_accuracy': lstm_val_accuracies,\n",
    "    'val_precision': lstm_val_precisions,\n",
    "    'val_recall': lstm_val_recalls,\n",
    "}\n",
    "\n",
    "# 绘制RNN和LSTM指标\n",
    "plot_model_metrics(rnn_metrics, 'RNN')  # 绘制RNN指标\n",
    "plot_model_metrics(lstm_metrics, 'LSTM')  # 绘制LSTM指标"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 七、图形界面（中文情感分析器），使用模型进行预测"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LSTM模型构建成功\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\17737\\AppData\\Local\\Temp\\ipykernel_18340\\2835334648.py:9: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
      "  model.load_state_dict(torch.load(f'model/{model_name}.pth'))  # 加载模型权重\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# 加载最佳模型\n",
    "def load_best_model(model_name):\n",
    "    model = None\n",
    "    if model_name == 'RNN_model':\n",
    "        model = RNNClassifier(vocab_size, embedding_dim, hidden_dim, num_layers, dropout).to(device)\n",
    "    elif model_name == 'LSTM_model':\n",
    "        model = ImprovedLSTMClassifier(vocab_size, embedding_dim, hidden_dim, num_layers, dropout).to(device)\n",
    "    \n",
    "    model.load_state_dict(torch.load(f'model/{model_name}.pth'))  # 加载模型权重\n",
    "    model.eval()  # 设置为评估模式\n",
    "    return model\n",
    "\n",
    "# 使用LSTM_model作为最佳模型\n",
    "best_model_name = 'LSTM_model'\n",
    "best_model = load_best_model(best_model_name)\n",
    "\n",
    "# 预测情感\n",
    "def predict_sentiment(text, model):\n",
    "    cleaned_text = clean_text(text)  # 清洗输入文本  \n",
    "    sequence = text_to_sequence(cleaned_text, vocab)  # 转换为索引序列  \n",
    "    sequence = torch.LongTensor([sequence]).to(device)  # 转换为Tensor并移动到设备  \n",
    "\n",
    "    with torch.no_grad():  # 禁用梯度计算，节省内存  \n",
    "        output = model(sequence)  # 模型前向传播  \n",
    "        probabilities = torch.softmax(output, dim=1)  # 计算类别概率  \n",
    "        _, predicted = output.max(1)  # 获取预测的类别  \n",
    "\n",
    "    confidence = probabilities.max().item()  # 获取最大概率值  \n",
    "    return (\"是一例正面评价\" if predicted.item() == 0 else \"是一例负面评价\"), confidence  # 返回预测结果和置信度  \n",
    "\n",
    "# 预测按钮的回调函数\n",
    "def on_predict():  \n",
    "    text = text_entry.get(\"1.0\", tk.END).strip()  # 获取输入框中的文本  \n",
    "    if text:  # 如果文本不为空  \n",
    "        sentiment, coef = predict_sentiment(text, best_model)  # 使用最佳模型进行预测  \n",
    "        \n",
    "        # 根据预测结果的不同，设置结果标签的颜色  \n",
    "        if sentiment == \"是一例正面评价\":  \n",
    "            result_label.config(text=f\"预测结果: {sentiment} \", fg=\"black\")  \n",
    "        else:  \n",
    "            result_label.config(text=f\"预测结果: {sentiment} \", fg=\"red\")   \n",
    "    else:  # 如果文本为空，弹出警告框  \n",
    "        messagebox.showwarning(\"输入错误\", \"请输入要分析的文本！\")  \n",
    "\n",
    "def clear_text():  \n",
    "    text_entry.delete(\"1.0\", tk.END)  # 清空文本框  \n",
    "    result_label.config(text=\"预测结果: \", fg=\"black\")  # 重置结果标签  \n",
    "\n",
    "# 创建主窗口  \n",
    "root = tk.Tk()  \n",
    "root.title(\"中文情感预测器\")  # 窗口标题  \n",
    "root.geometry(\"600x450\")  # 窗口尺寸  \n",
    "\n",
    "# 背景图片加载  \n",
    "try:  \n",
    "    bg_image = Image.open(\"background.jpg\").convert('RGBA')  # 打开背景图片并转换为RGBA格式  \n",
    "    bg_image = bg_image.resize((600, 450), Image.Resampling.LANCZOS)  # 调整背景图片大小  \n",
    "    bg_photo = ImageTk.PhotoImage(bg_image)  # 转换为PhotoImage格式  \n",
    "except FileNotFoundError:  \n",
    "    print(\"背景图片未找到，请检查文件名和路径是否正确。\")  # 如果文件未找到，则提示错误  \n",
    "    bg_photo = None  # 背景图片不加载  \n",
    "\n",
    "if bg_photo:  # 如果成功加载背景图片  \n",
    "    bg_label = tk.Label(root, image=bg_photo)  # 创建标签以显示图片  \n",
    "    bg_label.place(x=0, y=0, relwidth=1, relheight=1)  # 设定标签覆盖整个窗口  \n",
    "\n",
    "# 小标题标签  \n",
    "title_label = tk.Label(root, text=\"请输入语句：\", font=(\"Arial\", 14, \"bold\"), fg='black')  # 创建标题标签  \n",
    "title_label.place(x=100, y=20)  # 设置位置  \n",
    "\n",
    "# 文本输入框  \n",
    "text_entry = tk.Text(root, height=10, width=50, bg='white', fg='black', bd=0, relief=tk.FLAT)  # 创建多行文本框  \n",
    "text_entry.place(x=100, y=60)  # 设置位置  \n",
    "\n",
    "# 结果显示标签  \n",
    "result_label = tk.Label(root, text=\"预测结果: \", font=(\"Arial\", 12, \"bold\"), fg=\"black\")  # 创建结果标签  \n",
    "result_label.place(x=100, y=220)  # 设置位置  \n",
    "\n",
    "# 预测按钮  \n",
    "predict_button = tk.Button(root, text=\"预测情感\", command=on_predict, bg='#4CAF50', fg='white', font=(\"Arial\", 12, \"bold\"),  \n",
    "                           bd=0, relief=tk.FLAT)  # 创建预测按钮  \n",
    "predict_button.place(x=150, y=280, width=120, height=30)  # 设置位置和尺寸  \n",
    "\n",
    "# 清空按钮  \n",
    "clear_button = tk.Button(root, text=\"清空\", command=clear_text, bg='#F44336', fg='white', font=(\"Arial\", 12, \"bold\"),  \n",
    "                         bd=0, relief=tk.FLAT)  # 创建清空按钮  \n",
    "clear_button.place(x=300, y=280, width=120, height=30)  # 设置位置和尺寸  \n",
    "\n",
    "# 运行主循环  \n",
    "root.mainloop()  # 启动图形界面，开始接受用户输入"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
